{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/lib/python3.5/dist-packages/sklearn/cross_validation.py:41: DeprecationWarning: This module was deprecated in version 0.18 in favor of the model_selection module into which all the refactored classes and functions are moved. Also note that the interface of the new CV iterators are different from that of this module. This module will be removed in 0.20.\n",
      "  \"This module will be removed in 0.20.\", DeprecationWarning)\n",
      "/usr/local/lib/python3.5/dist-packages/h5py/__init__.py:36: FutureWarning: Conversion of the second argument of issubdtype from `float` to `np.floating` is deprecated. In future, it will be treated as `np.float64 == np.dtype(float).type`.\n",
      "  from ._conv import register_converters as _register_converters\n"
     ]
    }
   ],
   "source": [
    "import sklearn.datasets\n",
    "from sklearn.cross_validation import train_test_split\n",
    "import re\n",
    "import tensorflow as tf\n",
    "from sklearn import metrics\n",
    "import numpy as np\n",
    "import collections\n",
    "import time\n",
    "import os\n",
    "os.environ['CUDA_VISIBLE_DEVICES'] = ''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def clearstring(string):\n",
    "    string = re.sub('[^A-Za-z ]+', '', string)\n",
    "    string = string.split('\\n')\n",
    "    string = [y.strip() for y in filter(None, string)]\n",
    "    string = (' '.join(string)).lower()\n",
    "    return ' '.join([y.strip() for y in string.split()])\n",
    "\n",
    "def separate_dataset(trainset):\n",
    "    datastring = []\n",
    "    datatarget = []\n",
    "    for i in range(len(trainset.data)):\n",
    "        data_ = trainset.data[i].split('\\n')\n",
    "        data_ = list(filter(None, data_))\n",
    "        for n in range(len(data_)):\n",
    "            data_[n] = clearstring(data_[n])\n",
    "        datastring += data_\n",
    "        for n in range(len(data_)):\n",
    "            datatarget.append(trainset.target[i])\n",
    "    return datastring, datatarget\n",
    "\n",
    "def build_dataset(words, n_words):\n",
    "    count = [['GO', 0], ['PAD', 1], ['EOS', 2], ['UNK', 3]]\n",
    "    count.extend(collections.Counter(words).most_common(n_words))\n",
    "    dictionary = dict()\n",
    "    for word, _ in count:\n",
    "        dictionary[word] = len(dictionary)\n",
    "    data = list()\n",
    "    unk_count = 0\n",
    "    for word in words:\n",
    "        index = dictionary.get(word, 0)\n",
    "        if index == 0:\n",
    "            unk_count += 1\n",
    "        data.append(index)\n",
    "    count[0][1] = unk_count\n",
    "    reversed_dictionary = dict(zip(dictionary.values(), dictionary.keys()))\n",
    "    return data, count, dictionary, reversed_dictionary\n",
    "\n",
    "def str_idx(corpus, dic, maxlen, UNK=3):\n",
    "    X = np.zeros((len(corpus),maxlen))\n",
    "    for i in range(len(corpus)):\n",
    "        for no, k in enumerate(corpus[i].split()[:maxlen][::-1]):\n",
    "            try:\n",
    "                X[i,-1 - no]=dic[k]\n",
    "            except Exception as e:\n",
    "                X[i,-1 - no]=UNK\n",
    "    return X"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "12505"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dataset = sklearn.datasets.load_files(container_path = 'data', encoding = 'UTF-8')\n",
    "dataset.data, dataset.target = separate_dataset(dataset)\n",
    "_,dataset.data,_,dataset.target=train_test_split(dataset.data,dataset.target,test_size = 0.03)\n",
    "len(dataset.data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "vocab from size: 13353\n",
      "Most common words [('i', 20247), ('feel', 8632), ('and', 7325), ('to', 6926), ('the', 6379), ('a', 4882)]\n",
      "Sample data [4, 16, 11, 109, 49, 930, 39, 33, 42, 362] ['i', 'like', 'that', 'these', 'are', 'small', 'because', 'you', 'can', 'enjoy']\n"
     ]
    }
   ],
   "source": [
    "concat = ' '.join(dataset.data).split()\n",
    "vocabulary_size = len(list(set(concat)))\n",
    "data, count, dictionary, rev_dictionary = build_dataset(concat, vocabulary_size)\n",
    "print('vocab from size: %d'%(vocabulary_size))\n",
    "print('Most common words', count[4:10])\n",
    "print('Sample data', data[:10], [rev_dictionary[i] for i in data[:10]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "GO = dictionary['GO']\n",
    "PAD = dictionary['PAD']\n",
    "EOS = dictionary['EOS']\n",
    "UNK = dictionary['UNK']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_one_triplet(input_data, input_labels, n_labels):\n",
    "    index = np.random.choice(n_labels, 2, replace=False)\n",
    "    label_positive = index[0]\n",
    "    label_negative = index[1]\n",
    "\n",
    "    indexes = np.where(input_labels == index[0])[0]\n",
    "    np.random.shuffle(indexes)\n",
    "\n",
    "    data_anchor = input_data[indexes[0], :]\n",
    "    data_positive = input_data[indexes[1], :]\n",
    "\n",
    "    indexes = np.where(input_labels == index[1])[0]\n",
    "    np.random.shuffle(indexes)\n",
    "    data_negative = input_data[indexes[0], :]\n",
    "\n",
    "    return data_anchor, data_positive, data_negative, label_positive, label_positive, label_negative\n",
    "\n",
    "def compute_euclidean_distance(x, y):\n",
    "    d = tf.square(tf.subtract(x, y))\n",
    "    return tf.sqrt(tf.reduce_sum(d))\n",
    "\n",
    "def compute_triplet_loss(anchor_feature, positive_feature, negative_feature, margin=0.01):\n",
    "    d_p_squared = tf.square(compute_euclidean_distance(anchor_feature, positive_feature))\n",
    "    d_n_squared = tf.square(compute_euclidean_distance(anchor_feature, negative_feature))\n",
    "    loss = tf.maximum(0., d_p_squared - d_n_squared + margin)\n",
    "    return tf.reduce_mean(loss), tf.reduce_mean(d_p_squared), tf.reduce_mean(d_n_squared)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Model:\n",
    "    def __init__(self, size_layer, num_layers, embedded_size,\n",
    "                 dict_size, dimension_output,margin=0.2):\n",
    "        \n",
    "        def cells(reuse=False):\n",
    "            return tf.nn.rnn_cell.BasicRNNCell(size_layer,reuse=reuse)\n",
    "        \n",
    "        def rnn(embedded,reuse=False):\n",
    "            with tf.variable_scope('model', reuse=reuse):\n",
    "                rnn_cells = tf.nn.rnn_cell.MultiRNNCell([cells() for _ in range(num_layers)])\n",
    "                outputs, _ = tf.nn.dynamic_rnn(rnn_cells, embedded, dtype = tf.float32)\n",
    "                W = tf.get_variable('w',shape=(size_layer, dimension_output),initializer=tf.orthogonal_initializer())\n",
    "                b = tf.get_variable('b',shape=(dimension_output),initializer=tf.zeros_initializer())\n",
    "                return tf.matmul(outputs[:, -1], W) + b\n",
    "            \n",
    "        self.ANCHOR = tf.placeholder(tf.int32, [None, None])\n",
    "        self.POSITIVE = tf.placeholder(tf.int32, [None, None])\n",
    "        self.NEGATIVE = tf.placeholder(tf.int32, [None, None])\n",
    "        self.Y_ANCHOR = tf.placeholder(tf.int32, [None])\n",
    "        self.Y_POSITIVE = tf.placeholder(tf.int32, [None])\n",
    "        self.Y_NEGATIVE = tf.placeholder(tf.int32, [None])\n",
    "        encoder_embeddings = tf.Variable(tf.random_uniform([dict_size, embedded_size], -1, 1))\n",
    "        anchor_embedded = tf.nn.embedding_lookup(encoder_embeddings, self.ANCHOR)\n",
    "        positive_embedded = tf.nn.embedding_lookup(encoder_embeddings, self.POSITIVE)\n",
    "        negative_embedded = tf.nn.embedding_lookup(encoder_embeddings, self.NEGATIVE)\n",
    "        self.output_anchor = rnn(anchor_embedded,False)\n",
    "        self.output_positive = rnn(positive_embedded,True)\n",
    "        self.output_negative = rnn(negative_embedded,True)\n",
    "        self.cost, positives, negatives = compute_triplet_loss(self.output_anchor, \n",
    "                                                          self.output_positive, \n",
    "                                                          self.output_negative)\n",
    "        self.optimizer = tf.train.GradientDescentOptimizer(1e-4).minimize(self.cost)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "size_layer = 256\n",
    "num_layers = 2\n",
    "embedded_size = 128\n",
    "dimension_output = len(dataset.target_names)\n",
    "maxlen = 50\n",
    "batch_size = 128"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "tf.reset_default_graph()\n",
    "sess = tf.InteractiveSession()\n",
    "model = Model(size_layer,num_layers,embedded_size,len(dictionary),32)\n",
    "sess.run(tf.global_variables_initializer())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "X = str_idx(dataset.data,dictionary,maxlen)\n",
    "Y = dataset.target"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch: 1, loss: 52.063587\n",
      "epoch: 2, loss: 34.362415\n",
      "epoch: 3, loss: 92.985100\n",
      "epoch: 4, loss: 17.065908\n",
      "epoch: 5, loss: 41.615467\n",
      "epoch: 6, loss: 0.000000\n",
      "epoch: 7, loss: 0.000000\n",
      "epoch: 8, loss: 21.904287\n",
      "epoch: 9, loss: 0.000000\n",
      "epoch: 10, loss: 0.000000\n",
      "epoch: 11, loss: 0.000000\n",
      "epoch: 12, loss: 33.314075\n",
      "epoch: 13, loss: 114.887932\n",
      "epoch: 14, loss: 0.000000\n",
      "epoch: 15, loss: 40.939686\n",
      "epoch: 16, loss: 0.000000\n",
      "epoch: 17, loss: 0.000000\n",
      "epoch: 18, loss: 0.000000\n",
      "epoch: 19, loss: 0.000000\n",
      "epoch: 20, loss: 9.772329\n",
      "epoch: 21, loss: 41.573231\n",
      "epoch: 22, loss: 0.000000\n",
      "epoch: 23, loss: 11.069448\n",
      "epoch: 24, loss: 26.663565\n",
      "epoch: 25, loss: 0.000000\n",
      "epoch: 26, loss: 33.510365\n",
      "epoch: 27, loss: 0.000000\n",
      "epoch: 28, loss: 41.399036\n",
      "epoch: 29, loss: 0.000000\n",
      "epoch: 30, loss: 0.000000\n",
      "epoch: 31, loss: 8.973501\n",
      "epoch: 32, loss: 0.000000\n",
      "epoch: 33, loss: 0.000000\n",
      "epoch: 34, loss: 0.000000\n",
      "epoch: 35, loss: 54.119862\n",
      "epoch: 36, loss: 3.187856\n",
      "epoch: 37, loss: 72.178337\n",
      "epoch: 38, loss: 0.000000\n",
      "epoch: 39, loss: 29.311880\n",
      "epoch: 40, loss: 6.654043\n",
      "epoch: 41, loss: 0.000000\n",
      "epoch: 42, loss: 0.000000\n",
      "epoch: 43, loss: 0.000000\n",
      "epoch: 44, loss: 16.095205\n",
      "epoch: 45, loss: 0.000000\n",
      "epoch: 46, loss: 143.177597\n",
      "epoch: 47, loss: 0.000000\n",
      "epoch: 48, loss: 0.000000\n",
      "epoch: 49, loss: 0.000000\n",
      "epoch: 50, loss: 0.000000\n"
     ]
    }
   ],
   "source": [
    "for i in range(50):\n",
    "    lasttime = time.time()\n",
    "    batch_anchor = np.zeros((batch_size,maxlen))\n",
    "    batch_positive = np.zeros((batch_size,maxlen))\n",
    "    batch_negative = np.zeros((batch_size,maxlen))\n",
    "    batch_y_anchor = np.zeros((batch_size))\n",
    "    batch_y_positive = np.zeros((batch_size))\n",
    "    batch_y_negative = np.zeros((batch_size))\n",
    "    for k in range(batch_size):\n",
    "        batch_anchor[k], batch_positive[k], batch_negative[k], batch_y_anchor[k], batch_y_positive[k], batch_y_negative[k] = get_one_triplet(X, Y, dimension_output)\n",
    "    loss, _ = sess.run([model.cost,model.optimizer],\n",
    "                       feed_dict={model.ANCHOR:batch_anchor,\n",
    "                                  model.POSITIVE:batch_positive,\n",
    "                                  model.NEGATIVE:batch_negative,\n",
    "                                  model.Y_ANCHOR:batch_y_anchor,\n",
    "                                  model.Y_POSITIVE:batch_y_positive,\n",
    "                                  model.Y_NEGATIVE:batch_y_negative})\n",
    "    print('epoch: %d, loss: %f'%(i+1,loss))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "logits_test = sess.run(model.output_positive,feed_dict={model.POSITIVE:X})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "             precision    recall  f1-score   support\n",
      "\n",
      "      anger       1.00      1.00      1.00      1706\n",
      "       fear       1.00      1.00      1.00      1482\n",
      "        joy       1.00      1.00      1.00      4179\n",
      "       love       1.00      1.00      1.00      1103\n",
      "    sadness       1.00      1.00      1.00      3589\n",
      "   surprise       1.00      1.00      1.00       446\n",
      "\n",
      "avg / total       1.00      1.00      1.00     12505\n",
      "\n"
     ]
    }
   ],
   "source": [
    "from scipy.spatial.distance import cdist\n",
    "label_test = []\n",
    "for i in range(logits_test.shape[0]):\n",
    "    label_test.append(Y[np.argsort(cdist(logits_test, [logits_test[i,:]], 'cosine').ravel())[0]])\n",
    "print(metrics.classification_report(Y, label_test, target_names = dataset.target_names))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "sns.set()\n",
    "from matplotlib import offsetbox"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "from MulticoreTSNE import MulticoreTSNE as TSNE\n",
    "tsne = TSNE(perplexity=200, n_jobs=4)\n",
    "manifold_emotions = tsne.fit_transform(logits_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAApAAAAJ1CAYAAABuPMBhAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAIABJREFUeJzsnWmAVOWd7p/au5uq7uruKgTtoAKSIAK2IgiyGLZIxA2DYpbrFs1EnclNbiY3mrlG42TMjBlHZ9QkblGTKMYJ4yQSHYKMSRSRaDAqoi2LYCNOL1W9FN19ar0fsJrqqrO82zlV1f3/fas+1Wd5z6nzPu9/deVyuRwIgiAIgiAIghF3uU+AIAiCIAiCqC5IQBIEQRAEQRBckIAkCIIgCIIguCABSRAEQRAEQXBBApIgCIIgCILgggQkQRAEQRAEwYW33CdQSGdnv9D/NTbWIR4fUHw21Q+NSyk0JqXQmJRCY1IKjUkpNCal0JiUUs1jEo2GDLeNCguk1+sp9ylUJDQupdCYlEJjUgqNSSk0JqXQmJRCY1LKaB2TUSEgCYIgCIIgCOcgAUkQBEEQBEFwQQKSIAiCIAiC4IIEJEEQBEEQBMEFCUiCIAiCIAiCCxKQBEEQBEEQBBckIAmCIAiCIAguSEASBEEQBEEQXJCAJAiCIAhizJPMJNE50I1kJlnuU+Eml8shm806esyKamVIEARBEAThJJlsBht2b8QbnTsR13rQGAhjVnQG1kw9Fx63XBeZG2/8P4jFunD48CDWrl2HCy5YgxUrFuFzn1uHrVtfRCAQwA9+8M9oamrGwYPtuPXWv8PQ0CAWLlyCp556Ar/73R8BAI8//hi2bNmMVCqJxYs/jauv/goOHfoQ3/jGDTj55FPw7rvv4Ic/vBsTJkxUMSRMkAWSIAiCIIgxy4bdG/FC+4uIaXHkkENMi+OF9hexYfdG6X3feOPN2LBhAx566DH8+7+vR29vDwYHBzFjxkw8+ugTOPXUVvz61/8BALj77h9i7dp1eOyxJzF+/PjhfWzfvg0ffPABHnjgUfz0p4/j3Xd34fXX/wwAaG//ABddtBY///kvHRWPAAlIgiAIgiDGKMlMEm907tTd9mbXTml39lNPrcf555+Pa6+9Eh0d/4MPPvgAPp8PZ521CADwyU9Ox0cfHQIAvPXWm/j0p5cDAFasOGd4H9u3b8Of/rQNV175BVx11Rexf//7aG8/AACYMGEiTjllptQ5ikIubIIgCIIgxiS9Wj/iWo/utthQD3q1fkTrmoX2/ec/v4pXX92OJ598EolEGjfccC2SSQ1erxculwsA4Ha7kclkTPeTy+XwxS9egQsvvHjE3w8d+hA1NTVC56YCskASBEEQBDEmaQiE0BgI625rqgmjIRAS3vfhwwmEQvWora3F/v3v4+233zL9/owZp+D3v98CANi8edPw3+fNm4+NG3+NgYEBAEBnZwfi8ZjweamCLJAEQRAEQYxJ/B4/ZkVn4IX2F0u2zYzMgN/jF973vHkL8PTTG7Bq1Socd9wncPLJp5h+/2/+5v/ge9/7f3jssYcxb958jBsXBADMnXsm3n9/H/7qr64EANTW1uHmm2+D211eG6Arl8vlynoGBXR29gv9XzQaEv7f0QyNSyk0JqXQmJRCY1IKjUkpNCalVOOY5LOw3+zaidhQD5pqwpgZUZOFDbCPydDQEAKBAFwuFzZv/i9s3vxf+MEP7pQ+vgzRqLEFliyQBEEQBEGMWTxuD9ZOOx8XTDkHvVo/GgIhKcujKO++uwt33vlPAHIIBkO48cabHT8HHkhAEgRBEAQx5vF7/MIJMyqYPbsVjz76RNmOzwsl0RAEQRAEQRBckIAkCIIgCIIguCABSRAEQRAEQXBBApIgCIIgCILgggQkQRAEQRCEDTz11HqsWrUKt976d+U+FeVQFjZBEARBEGOerKYh3dsLb0MD3IGAkn3+x388hZ/97DF4POOE95FOp+H1Vp5cq7wzIgiCGANoqQx6ExoaggEEfPLFigmCECOXyaDzqfVI7Pgz0rEYvE1NCLaehujadXB5xH+bd9zxD/jww4O45pprsGTJMhw82I59+/YgnU7jqquuxaJFZ+PQoQ9x2203Y2hoEADw9a9/CzNnzsaf//wqHnzwxwiFQti/fz/Wr9+g6nKVQQKSIAjCQTLZLJ7cshs72joR69PQVB9A67QoLl06FZ4ytyYjiLFI51Pr0bP5d8Of093dw5/Hr/uC8H7/9m9vwiuvvIxHH30U9913P04//QzcdNN30d/fj2uuuRxz5sxDY2MT/uVf7kUgEMAHHxzALbd8Bw899DMAQFvbO3jssSdx7LHHyV2gTZCAJAiCcJAnt+zG5lfbhz9392nDnz+/fFq5TosgxiRZTUNix591tyV27EDkos8pcWdv374NL774ezzxxM8BAMmkhv/5n48QiUTxL//yj3jvvTa43R588MH+4f+ZPn1GxYpHgAQkQRCEY2ipDHa0depu29HWhYuXTCF3NkE4SLq3F+lYTH9bPIZ0by/848dLHyeXy+H73/8nTJp0woi/P/TQT9DY2IxHHnkC2WwWy5adNbyttrZW+rh2Qv4SgiAIh+hNaIj1abrb4v1D6E3obyMIwh68DQ3wNjXpb2tsgrehQclx5s2bj3//9yeRy+UAHHFPA8Dhwwk0N0fgdrvxX//1W2QyGSXHcwISkARBEA7REAygqV7fHdYYqkFDUE3mJ0EQbLgDAQRbT9PdFmxtVZaNfcUVVyOdTuPyy9fhi1+8BA8++GMAwEUXrcVzzz2Dyy+/DPv3v1/xVsdCXLm8HK4AOjv7hf4vGg0J/+9ohsalFBqTUmhMSrFzTB7f3DYiBjLP8jktFR0DSc9JKTQmpVTjmBzNwt6BdDwGb2MTgq2t0lnYeapxTPJEoyHDbRQDSRCE7dhRX61auXTpVABHYh7j/UNoDNWgdVpk+O8EQTiLy+PB+HVfQOSiz9F7igMSkARB2IZd9dWqGY/bjc8vn4aLl0yhOpAEUUG4AwElCTNjBRKQBEHYhl311UYDAZ8H4xvryn0aBEEQQlASDUEQtmBVXy2rUcYxQRBEtUICkiAIW2Cpr0YQBEFUJ0oE5I033oj58+dj9erVw3/r6enBlVdeiZUrV+LKK69EL00WBDGmcKq+GkEQBOE8SgTkmjVr8OCDD4742/3334/58+dj06ZNmD9/Pu6//34VhyIIokpwqr4aQRBEpfJXf3VVuU/BNpQIyDPOOAMNRdaE559/HhdeeCEA4MILL8TmzZtVHIogiCoiunYdwstXwNscAdxueJsjCC9fgejadeU+NYIgiBFkNQ3Jjg6l8dk//vHDyvZVadiWhd3d3Y3xH6fDR6NRdHd323UogiAqFKqvRhBEpWNnubEVKxZhx44duPfeu7Ft20twuVy4/PKrsWzZStx2281YsmQpFi8+GwBw661/h6VLl2PRorPlL8oBHCnj43K54HK5LL/X2FgHr1fsZplVSx/L0LiUQmNSiv1jEgJaIjYfQy30nJRCY1IKjUkp1TYmex94WLfcWG2NH5OvkXNBu1wubNq0Cfv378HGjc8gHo/jc5/7HJYuXYQvfvEyPPLII7j44vPQ39+Pt99+E3fd9c/wequjwqJtZ9nc3IyOjg6MHz8eHR0daDIIpi8kHh8QOlY1twmyExqXUmhMShkLY5LMJNGr9aMhEILf47f8/lgYE15oTEqhMSml2sYkq2nofHmb7rbOl1/BuFXnS3lNcrkcXnvtNSxevAyx2ACAAGbNOhUvvbQdCxcuwZ49+9DWdgC///3zWLTo04jHB4WPZQdlaWW4dOlSPP3007j22mvx9NNPY9myZXYdiiAIQpdMNoMNuzfijc6diGs9aAyEMSs6A2umnguPm7q/EMRYh6XcmJ3dac4557PYtOm32Lx5E2666bu2HccOlCTRfOMb38C6deuwb98+LF68GE899RSuvfZavPTSS1i5ciW2bt2Ka6+9VsWhCIIgmNmweyNeaH8RMS2OHHKIaXG80P4iNuzeWO5TIwiiAnCi3NicOXOwZcvvkMlkEI/H8frrOzB9+gwAwGc/ex5++csnAAAnnjhZ+lhOosQCeeedd+r+/dFHH1Wxe4IgCG6SmSTe6Nypu+3Nrp24YMo5TO5sgiBGL/lyY4UxkHnUlBtzYcWKFdi6dTuuuOIyuFwuXHfd36C5+UhMeFNTM44//kQsXrxE8jjOUx2RmgRBEJz0av2Iaz2622JDPejV+hGta3b4rAiCqDTyZcUSO3YgHY/B29iEYGurdLmx3t4e1NfXw+Vy4frrv4brr/9ayXeGhobQ3n4Ay5efI3WsckACkiCIUUlDIITGQBgxLV6yrakmjIZAdWWKEgRhD3aUG+vq6sQNN3wFl132RcPv/OlPr+AHP7gNl176eQSDQanjlQMSkARB2E4yk0V/Ko2Qzwu/R0notSV+jx+zojPwQvuLJdtmRmaQ+5ogiBG4AwFlCTORSBTr128w/c4ZZ8zDr371jJLjlQMSkARB2EYml8OzB7qwqyeBnmQaYb8X08NBrJoUgYehNqwsa6aeC+BIzGNsqAdNNWHMjMwY/jtBEAQhBglIgiBs49kDXdjacTQOMZ5MD39efXzU9uN73B6snXY+LphyDlcdSIIgCMIcZ3xJBEFULalUBr3xQaRSGa7/S2ay2NWT0N22qyeBZCar4vSY8Hv8iNY1k3gkCIJQBFkgCYLQJZvNYuuWPdjX1oVEn4ZgfQAnTotgwdIpcLut1579qTR6kmndbT3JNPpTaTSToCMIgqhKyAJJEIQuW7fswZuvHkSiTwMAJPo0vPnqQWzdsofp/0M+L8J+/TVq2O9FyEfrV4IgRi8rViwq9ynYCglIgiBKSKUy2NfWpbvt/bYuJne23+PG9LB+aYrp4aBj2dgEQRAsZLMppLQYstlUuU+lKiATAEEQJQwkksOWx2IS/RoGEkk0NNZa7mfVpCPdFvSysAnCjKymKavJRxBm5HJZxA9uwmDPu8ikeuHxNaA2/Ek0HrcSLpf8QjeXy+Hee+/Gtm0vweVy4fLLr8ayZSvx3e/eiM985lwsWLAQAPD979+CBQsWYvHiT+PHP74HO3a8hlQqiYsuWosLL7xY+jxUQwKSIIgS6oJ+BOsDuiIyGAqgLsgWu+hxubD6+ChWtjQ7XgdyNJHNppBJ9cPjC8Ht9pX7dGwll8mg86n1SOz4M9KxGLxNTQi2nobo2nVweTzlPj1iFBI/uAmJzu3DnzOp3uHPTS3yHWI2bdqE9957F4888gR6e3vw5S//L8yefRqWLl2JLVt+hwULFiKVSuG11/6Eb37z23jmmf/EuHHj8OCDjyGZTOKrX70ac+eeiWOPPU76XFRCApIgiBJ8Pg9OnBbBm68eLNl2wrQIfD6+idzvcVPCjACylpFqtOJ1PrV+RF/idHf38Ofx675QrtMiRinZbAqDPe/qbhvsaUP22GXSi7bXXnsNy5d/Bh6PB01NzWhtPQ3vvLMTZ565AHff/UMkk0m88spWzJ7dikCgBn/60zbs3r0bL7ywBQBw+HAC7e0fkIAkCKI6WLB0CoAjMY+Jfg3BUAAnfJyFPZZQbf3j2Z+oZUTGipfMJMtWMzOraUjs+LPutsSOHYhc9LmqEcJEdZBJ9SOT6jXY1otMqh/uQJMtxw4EAmhtPR3bt7+M55//HZYvXwngiMv761//W8ybN9+W46qCBCRBELq43W4sXH4S5i2ZjIFEEnVBP7flkYdKs5apjovi3Z+MZUTEipfJZrBh90a80bkTca0HjYEwZkWPdO3xuJ1xHad7e5GOxfS3xWNI9/YqazVHEADg8YXg8TXoikiPrwEeX0j6GHPmzMHPfvYLrFq1Gn19fXj99R247rqvAQCWLVuJ3/zmabz77i585zu3AADmzp2Pp5/+d5x++hnwer04cGA/otHxqK21jjt3EhKQBEGY4vN5mBJmRKnUmDfVcVG8+xO1jIha8Tbs3jiib3hMiw9/XjvtfJMrU4e3oQHepiaku7tLtzU2wdvQ4Mh5EGMHt9uH2vAnR/w289SGpynxOqxYsQJbt27HFVdcBpfLheuu+xs0Nx9JJJw790zcdtvNWLRoCXy+I8c677wL8dFHh3DVVV9ALpdDONyI22//Z+nzUA0JSIIgykolxrxlM0mlcVEi1kRRy4iIFS+ZSeKNzp26//Nm105cMEU+kYAFdyCAYOtpI56HPMHW1oqwTBOjj8bjjriOB3vaCrwD04b/LsrvfvdHAIDL5cL1138N11//tZLveL1ePPvslhF/c7vd+MpXrsdXvnK91PHthgQkQRBlo1Jj3lJan9K4KBFroqhlRMSK16v1I671lPwdAGJDPejV+nEcmnW3qya6dh2AI/c/HY/B29iEYGvr8N8JQjUulxtNLecge+yyMVPtQAUkIAmCKBuVGvPmC9QrjYsStSaKWEZErHgNgRAaA2HEtHjJtqaaMBoC8nFgrLg8Hoxf9wVELvpcRcXEEqMft9tnW8LMaIQEJEEQZUNVzJvqzGG3x680LkrUmihqGeG14vk9fsyKzhgRA5lnZmSG49nYwBEhTAkzBFG5kIAkCKJsyMa82Zk5rDouSmZ/vJYRESvemqnnAjgS8xgb6kFTTRgzIzOG/04QBFEICUiCIJQgWi9RJubNzsxh1XFRqveXzGQtu/vwWPE8bg/WTjsfF0w5R9qaW2klmQiCUA8JSIIgpJCtlyga88aSOazEna04Lkp2f5lcDs8e6NLtL+5xuaTPz+/xI1onljBTqSWZCIJQDzWlJQhCinx9w3yCSL6+YfzgJq795K1lrBYrlszh0cizB7qwtaMH8WQaOQDxZBpbO3rw7IGucp/acEmmdHc3kMsNl2TqfGp9uU+NIKqGQ4c+xJe+dEm5T8MSEpAEYSOpVAa98UGkUplyn4otWNY3zKZsO3Y+c1gPpzOHnSKZyWJXT0J3266eBJKZrNB+s9kUUlpM6n5ZlWTKaprwvgnCCVT8DsYS5MImCBvIZrPYumUP9rV1IdGnIVgfwIkf95F2u0fPuq2cfWQrMXPYbvpTafQk07rbepJp9KfSaOa4bt7wg1QqY9jWslJLMhGEFarbluYZHBzEzTd/G7FYF5LJFK644ss4cGA/Xnrpj9C0IZxyymx861s3weVy4Z13duH2278H4Eh3mjy//e1v8OKLf8DQ0BA+/LAdixefPdwGcfv2bXjooZ8glUri2GNbcNNN30VdXR1+9KN/w0sv/QEejwdnnHEmbrjhf2PLls346U/vh9vtQTAYxL33PiA3aCABSRC2sHXLHrz56sHhz4k+bfjzwuUnleu0lONEH1kzRlPmMEsSUsjnRdjvRVxHRIb9XoR8fK901vaK2WwWzz39Ft7+y4eGCyJqQ0hUK6rbluZ55ZWtiESieOSRh9HZ2Y9EIoEzzpiHK6+8BgBw223/Dy+99EcsXLgYt99+K77+9W/h1FNPw7333j1iP++914af/vQX8Pl8+PznL8bFF1+KQKAGjz76EO666z7U1tbi5z9/BE8++QusWbMWf/jDf+Pxx38Fl8uF/v4joTyPPPIA7rzzHkSj44f/JgsJSIJQTCqVwb42/Xi099u6MG/J5BLrTTnIC5ZsRjxL1ok+soVoqQx6ExoaggEEfB6lmcPlgsf64fe4MT0cxNaO0tjP6eGgYTa2HjztFVkWRNSGkKhGRNqMsjJ58lTcc89duOOOO9DaOg+zZ7fihReexy9+8Rg0bQh9fX044YQpmD27Ff39/Tj11NMAAJ/5zGexbdtLw/uZM+cMBINBAMAJJ0zGRx99hESiH++/vxdf/erVAIB0OoUZM2Zi3Lgg/P4Abr/9ezjrrEVYsGARAGDmzNn4/vdvwdKlK7BkyaeFrqcYEpAEoZiBRBKJPv14r0S/hoFEEg2NtQ6f1VGKBUv33kb4QycJu2tY6huauT5ZyGSzeHLLbuxo60SsT0NTfQCt06K4dOlUeNxuqcxhuykWvcXwWj9WTYoAgG4WNg+s4Qc8CyJqQ0hUG3aG4UyadDwefvjneOut1/DAAz/C6aefgQ0bnsKDDz6GY46ZgIce+gmSSevYYJ/vqID1eNzIZNLI5XKYM2cebr31H0q+/8ADj+K117bjv//7efzqV7/Ev/7rj/G3f3sTdu58Cy+//CKuvvpLeOihn6GhQT+GnBUSkAShmLqgH8H6gK6IDIYCqAuW10JWLFiSQ3Ekh8TdNWb1DVXFgj65ZTc2v9o+/Lm7Txv+/Pnl00Z8t1JqEFqJXkDM+uFxubD6+ChWtjSb1oG0GgfW8AOeBRG1ISSqDTvDcLq6OhEK1eOCCy5ALufDM888DQAIh8MYGBjACy88j7PPXoZQKIRQKIS//OV1zJ59KjZtetZy3zNmzMSdd/4j2ts/QEvLJzA4OIjOzg5EIlFo2hDmz1+ImTNPxSWXXAAAOHiwHTNmnIIZM07Btm1b0dHxPyQgCaLS8Pk8OHFaZITLL88J0yJldV/b6a7Rq2+oIhZUS2Wwo61Td9uOti5cvGQKAj6PbTUIRQuks4heGeuH3+PWTZhhHQfW8AORBRG1ISSqBTvDcPbs2Y377rsbPp8XgBvf/Oa38Yc/vIAvfelSNDc3Y/r0GcPfvfHG7+L2278Hl8uFuXPnWe67sbER3/nOLbjllu8glUoCAK655quoqxuHG2/8BpLJJHK5HP76r78OALj33rvR3n4AuVwOp58+F1OnTjPbPROuXC6Xk96LIjo7xQI7o9GQ8P+OZmhcSnFqTPKWt/fbupDo1xAMBXBCBWRhp7QYDr19j8FWFyaefD18irKmU6kM1j+wXVd4hOoDuPSauUxiuiM+gBt/sg16Lyq3C/iHa8/E+MY6dKz/hW78XXj5Coxf9wWuc49GQ+jo6BXOzNRSGfzdA9vQrXPtzfU1+Ptr5iHg8yCbTeHQ2/cZWD/CmHjyV7knMJ5xOBrOUBp+UHiNL25+T3dBNHPOcYYLgUqxBNsJvWNLqcYxYf0diFKNY5InGjW2wJIFkiBswO12Y+HykzBvyWSp2D9eVLktVaAqFrQhGEBTfUBXjDWGatAQDFjWIIxc9DluESOTmdmb0BAzuPZ4/xB6ExrGN9Ypt37wjgNre8UFS6egttaPXX/5sGRBVAx1oyGqDdVtRscKJCAJwkZ8Po8jCTOq3ZYqUBULGvB50DotOsIdnKd1WgQBnwfJjm6lNQizmaSUq59F9A5/ZkhCYkW0FqNVe0W3241zLjwFs+a2WC6I8t1oho/7cTcaANyWYIJwEtVtS0c7JCAJYhTAM2kXCxZ/TXg4C1sUvThBlbGgly6dCuBIzGO8fwiNoRq0TosM/111DcKU1ieVmckievOotH7IjoNVvKfVgsgOSzBBEJUJCUiCqHJk3ZYTJk5Ed0yszZxVDcO8i1MvFpQHj9uNzy+fhouXTNEtiaO6BqEvUC/t6rcSvcWosH6IjoOqThzUjYYgxg4kIAmiypF1W7o9fgBiAtIqTlB1LGjA58H4xjrdbSprELo9fmlXv5XotQuRcVDViYO60RDE2IEEJEFUCUbuxXJN2jwlgZyIBVVdg1BVbKKZ6LUD3nFQWdqJutEQxNiBBCRBVDhW7sVyTdp2dnCQQbQGYWEGOxCq+sxM1nFQfR+rrRtNMpM1LciuGtG6ogRhxDe/+Tf47ne/j1BIXRUNFkhAEkSFw+JeLMek7WRJIDvRy2A/PP9MBM9bA5fH40hmphOiwugYqu+jjCXYydqRmVwOzx7o0m0J6XG5lB9PVZwpYR9WbUedIp1Ow+u1lme5XA65XA4//OG/OnBWpZCAJIgKhtW9WI4Wck6WBLITvQz2Q89sRHgoKV12xkoY8ooKkQnO0oJtw33MZlPI4DC8kUam/y9H7chnD3Rha0fP8Od4Mj38efXxUeXHUxVnSqiHpe2oCIODg7j55m8jFutCMpnCFVd8GT/60b/hwQd/hnA4jHfeeRv33HMX7rnnfjz00E/w4Yft+PDDgxg/fgLmzZuPP/zhv5FIJNDV1YmVK1fhqquuxaFDH+Ib37gBJ598Ct599x388Id344YbrsWDD/4MgUAAN9/8bXR0dCCbzeCKK76MZctW4p13duGee/4FAwMDCIfDuOmmWxCJRKTHjQQkQVQwvO5Fp1vIqaxhWA7sKjvDKgxZRYXMBMdyDFX3UdTK5nTtyGQmi109Cd1tu3oSWNnSrNSdbWcLUUIelrajIrzyylZEIlE88sjD6OzsRyKRwI9+9G+G39+3bx9+9KMHEQjU4Le//Q127dqJxx57EjU1Nfjyl/8XFixYiIaGMNrbP8B3vnMrTjllpu7x7rjjbgBAIpFAOp3GXXfdgdtv/2c0Njbi+ec34f7778VNN31X+LrykIAkiApGhXvRzhivao8TtKvsDIto4xEVohMcswXb4j5qqQwOdR1GJpUxtXyKWNnKUTuyP5VGTzKtu60nmUZ/Kq3bZ1wU0TjTZCaJXq0fDYEQ/ArPhziKlspgR1un7rYdbV24eMkUYXf25MlTcc89d+GOO+5Aa+s8zJ7davr9hQsXIxCoGf48Z848NDSEAQBLlizFG2+8jkWLzsaECRNLxGPh8e67719x1lmLMHt2K/bu3Y29e/fg61+/HgCQzWbQ3CxvfQRIQBJERSPjXnQyxqtaOzjYkcHOKtpYRYXMBMdtwS66jyMsn/0amkLGlk9RK1s5akeGfF6E/V7EdURk2O9FyKd2auRdCGayGWzYvRFvdO5EXOtBYyCMWdEZWDP1XHjc1A5SJaxtR0WYNOl4PPzwz/HWW6/hgQd+hNNPPwMejwe5XBYAoGnJEd+vqRlZqcJV8p52ffy9GuiRP97LL780fLzFiz+NE0+cjJ/85KdC12AGRe4SRIXTeNxKBKNz4fGFAbjg8YURjM61dC/mY7ziyTRyOBrj9eyBLkfOuxrIZ7DrIZrBziLagKOiQo9CUcEywRnBegwj8pbP7j4NudxRy+eTW3brXBvbdReTF/G622wqQ+X3uDE9HNTdNj0cVG6pzy8E9dBbCG7YvREvtL+ImBZHDjnEtDheaH8RG3ZvVHpexNG2o3oUtx3lpaurE4FADS644AJcdtlw6NcVAAAgAElEQVSX0Nb2DiZMOBbvvLMLAPD73z9v+v9/+tMr6OvrhaYN4Y9/fAGzZs1mOt5nPvPZ4eNNmnQ8enrieOutNwAcSdDZu3eP8DUVQhZIgqhwRNzETsd4qcbJbFy9DPbo/HkInrdGaH+s1iZW6zJPX+1iZCzYvJZP0XALkTJUKly7qyYdcePpWejtgDXONJlJ4o3Onbr7eLNrJy6Ycg65sxXC03aUlz17duO+++6Gz+cF4MY3v/ltaJqG22+/DQ8++GO0tp5u+v8nnzwD3/nOt9DZ2YGVK1fhU586GYcOfWh5PJfLDa/Xi29+89vw+Xz4+7//R9x11w+RSCSQyWRwySWXYfJkvm5gerhyuVxOei+K6OzUX6FaEY2GhP93NEPjUko1jImKybF7KIk739wPvR+3C8A3Zh6P5poj+3ZyTCyzksuQjTt8bgWi9ZiWiNSYxNqf0xVtwejcEbGAR5NOSkVFYdLJ45vbdCe45XNaLIP8WY9RTEd8ADf+ZJvuM+R2Af9w7Zklrj3W6y45x+H7XlqGqvC+2+HalYkRFvntWP0GOge6ceu2f0JOZ+RdcOG7Z34L0bpmrmM6STW8Y4s5GqpR2nZUJgs7j8iY/Pa3v8E777yNb3zj/0ofX4Zo1NhLQRZIgqgQVE6OTsd4WcGanet0Nm4hLBnsrOKe1drEal3m7astcoxiRCyfotncrGWo8q7dPHnXLgCsnXa+5TXp4fe4pRJmeGt4WsULNwRCaAyEEdPiJduaasJoCFRHfdVqolxtR6sdEpAEUSGonBzzMV6Fde7y2BHjZQVTVrJgNi7vBC5SS5FX3POKNitRoWKC4010EnHtyWblm4n4SnPt5nJZfPDOf6L70JtKC4P7PX7Mis4Y8S7IMzMyg9zXNuJ021EzPvvZ8/DZz55X7tMwhQQkQVQAdkyOKmK8VHRmYM3O5c3G5a05KFNLUVTcq85Od3qCE7V82pGV36v1I66VLogAIDbUg16t31HXrp2FwddMPRfAkd9+bKgHTTVhzIzMGP47QVQCJCAJogKwY3L0uFxYfXwUK1uauWO8VHZmYC0lw1tSh3cCF62lWA7LV6XU/yu0fHr8PmSSKSnXnsx1VZJr1+7C4B63B2unnY8LppxTEc8BQehBApIgKgA7J0eRGC+VnRmYs5I5snF5J3CZWopOWr5E42BZstZTqQwGEknUBf3wcYrAgM+DaGSccHKEivjeSnLtihYG58Xv8Vd0wgwxtiEBSRAVQCVNjqo7M/CUktErqZPPxi2EdwKXKRbspOWL11XOkrWezWaxdcse7GvrQqJPQ7A+gBOnRbBg6RS4FWSY2nFdRlSKa1dFhyiCqHZIQBJEhVApk6MdnRmYs5IZs3F5J3CZWoq84l7UTSviKmfJWt+6ZQ/efPXg8HcSfdrw54XLT2I+P1FUhgBUimtXpr4mQYwWSEASYxInC1WzUimTo4zYMoI7K9mipA7vBC5bLJhF3Mu6aXld5SxZ6xm3F/va9DsPvd/WhXlLJnO7s3mxIwSgEly7jcetRF2tH92H3uIqWUQQowUSkMSYIpfJoGP9L8pSqJoVs8lRNrmCJavazs4MKrNzeWsOytRSZBH3sm5aXlc5S9b6oC+EhIE1OdGvYSCRRENjre52VVRS8otKXC43PvGpC+BvXCRUskiESlz4EmMXEpDEmGLfw4+WrVB1MTz1C2WtW2ZZ1XqwiC3RyUxVhrGVVbO4w4iKWopG4l6Fm5bXVc6StV7n9iJYH9AVkcFQAHVBvvEXuXeVFN9rB3aULCqmnB2aCMIIEpBERWHnCjuraYhtL3V5AuaFqlXDW78QkLdumWVVf+2y0n6sZmJLdDKzow0dUDqBZ3I5PHugS7f+pcflsqWWoio3LU8cLEvWuhvAidMiI2Ig85wwLcLsvs5kM3hkxy+xbf/rQveuUuJ7q5VydmgiCCNIQBIVgRMr7HRvL7RO/XgwvULVdsFbv1DWumWVVT2k0+4wj57YEp3M7GhDp8ezB7pGdOCJJ9PDn1cfH7X8/1Qqg1jXYaRSGWaBpcpNyxsHy5K1vmDpFABHYh4T/RqCoQBO+DgLmxXZe1cp8b2VjFF4iWiHJoKwGxKQREXgxArb29CAQDQCraNUTOkVqrYDkQLEstYtq6zqeJ824kVgVi9QdDJzqhh3MpPFrp6E7rZdPQmsbGk2LKY+otzNx0KLtdyNajcta5IIS9a62+3GwuUnYd6SyUJ1IFXeO6eSX6opVtCqaD9vhyaCcAoSkETZcWqF7Q4E0DR3Lg49s7FkW3Ghapmiy2aIFCCWtW5ZZVU31gfQ3zvIVC9QdDJzqhh3fyqNHgOLak8yjf5U2rCoumy5m3K6aa2y1gHA5/MIJcxUWgtBMyoxVtAqcc2qaD9vhyaCcAoSkETZcXKFfeJVl2NwKGno8rO76LJIAWJZ65ZVVnWN34t+sAko0cnMqUzckM+LsN+LuI6IDPu9CPn0X3mpVEa63M1oddNWUxZ1JcUKsrQDZSraz9GhiSCcxJk2BARhQl6U6G5TvMLOu/xO+N73ccLf/wAnfO/7GL/uC8PWibyIymet5kXU1i17lBw/X79QD7MCxGumnouzWxaiuaYRLrjQXNOIs1sWMlu3Ll06FcvntKC5vgZuF9BcX4Plc1qGs6qtBFQqlTly/h9PZnqYTWZ5EaxHsQjOahqSHR3IavpudzP8Hjemh4O626aHg4bu64FE0rLcDfs5HHHTjgbxCPDdO7tIZpLoHOhGMmN8H6w8GazPk5bKoCM+AO3jZ16UvGWxu09DDkcti09u2T38HZai/cCRWNfw8hXwNkcAtxve5gjCy1eUdGgiCCchCyRRdnh6IANqysDoufxUWKFY4K1fCMhbt6xK2LAIqLz7k7XdYDFWLl5V7sdVkyIAoJuFbURd0K+03M1oY83Uc1FX58MrB14vuXd2xhvyZO7LejJYLIassLYDZS3az9qhiSCchAQkURGwiBK7ysDk4RFRMvB2ZSlENgnBqIQNj4ASncysRLAq96PH5cLq46NY2dI8og6kGT6fR0m5m9GKx+3BFa2XYMXEZcP3zgcPOn9pb7whT/a3bKygVSwiD6ztQHmL9rPEuhKEU5CAJCoCFlFidxkYp61QThQgZkVEQIlOZnoi2I5EKr/HbZgwo4douRtVhdGrgcJ717H+F7bGG/Jmf/N6MgphtRiywtMOVKZDEkGUExKQREVhJEqcKAMz1q1QKuoF5uEVVeUuVZLvCrRg6QmYt2Qyavw+DCVTpvfcbot4JeNE5QSR7G/R8ApWiyErPJZFvfASXzaNdFcXXOSqJioYEpBEVeBUKRGVIqrakK0XCIiLqnKVKjHqCjRx9hp0dWdN/1elRbwcdQt5WmkW44TgF8n+NvNkmF0vj8WQFV7LYsDnQbQ+UHFliAjCCBKQRFXgVCkRFSLKTmQmfVZE6wUC4qJKxv0og1FXoPY2P2qalxr+nyqLeDnqFoq00izGCcEvU76q0JPBcr28sYgsiPRer6QyRARhBZXxIaoCp0uJ5EVUpYjHXC6LWPtzOPT2fTj09j049PZ9iLU/h1zO3ErmJFaiyqwEC+B8qRKzrkA9HTuRzaYM/5fFIs5CXjCku7uBXG5YMHQ+tZ7p/0XIi+Z8LdK8aI4f3MS8D9FyTrzIlq8C2K/XqtSVKPnENSvxqKoMEUE4BVkgiaqhnJ0+yg1v/+xyIBtm4HSpErOuQMmhHt2uQHlUWMRl4whFrNEirTSNYI03lLGay5av4rleEYshD1YdacodB0wQvJCAJKqG0drpwwqVk77wOTDE6KkKM3CqVIlZVyB/TVi3K9DwdgW9r0UFg4wLWqSVphFWgl+FqzyPWfkqs7ajItdrVOpKFNb6kqJhAU6EtRCEHiQgiapDthZitSE66VtZPFjgidFTIapUYpUJnu8KVGjZzRMeP8NyMpa1iIsKBhlrtEgrTT2KFxR6QlfWam61aGFpO6rqemVgrS/JGwesUqAThAgkIAlHKEeW6WiBdxJU2VGDN6hfVFSpfD54MsGNugK1TFuNru4B0+PIWsRFEodkrdFmotmslWYe1gWFzHmyHoOld7vs9crCW1+SpwxRNYS1EKMbEpCErZQjy7Qc2CmQeSdBVR01RGL0eEWVHc8HTya4UVcgF0cdRxmLOG/dQhUuaJFWmnlYFxQy58lyDJ62ozLXKwtvfUnWOOBKCGshCBKQhK2M9rIUTglk1klQZUcNmaB+VlGl+vkQLa9Trq5AvIlDKlyyoq00MxwLCtHzZF208LQdlWkdKotofUmrOGCVsawEIQoFShC2MRbKUqgqw5JKZdAbH0QqldHdnp8EJ578VUw8+XpMPPmraGo5pyTWicXiwUo+Rk93m4Jaf3Y8H6rK6zhNXjBYWa/z1mg9eF2ybrcPvkAT8/8kY3HLBYXsebIsWoCjbUf1MGo7ynu9KsjXl9RDtL4kcFSg629zJraTIEhAErbBOhlUKyoEUDabxYub38P6B7bj8Z+8gvUPbMeLm99DNqtf39FqEsxbPPTg7ahhd60/kecjq2lIdnQYjm0+E1wPlQXny0njcSsRjM6FxxcG4ILHF0YwOlfKJZvNppDSYqa1L/1NjVwLCpHzZF205NuO6lFpbUftqC+pciFBEKKQC5uwjXK1p3MKFXXbWBIBeFDdUUO0tzBLTCjP88EaKlBpmeB2wOOStboPPJm8Hs6kHxHXMU9iUbW0HbWrvmQ5YzsJAiABSdhIudrTOYWsQOZJBOCBtwcvYFzyhjdGjycmlOf54ImVNMsEtyrtU02YxW2y3gfeTF6RBQVvfCnrMZxqO6qqzqLq+pLljO0kCIAEJGEzohasakBWIPMkAvDAY/HIZDN4ZMcvsW3/66Ylb1iLe/MmxbA8H7zZ4HqZ4B6Xh7m0z2iA5T6IZPI60S3I6BhaKoPevoGS51mkdzuLKLSzzqKKGq15ypUARhAkIAlbcbo9ndPICOR8IoCeiDRKBOCBxeLBU/LGCpGyPyzPh2ioQGEm+FNtv1Z2neWC1XrKeh9kMnmd6BaUP0Ymm8Xjm9uU1DXlEYV21FlUWaNVlGQmi/5UGiGfF34PpUEQ4pCAJBzBqfZ0TiMjkPOJAIUxkHmcSAQQLXljhExMqNnzIRsqoPo6ZeF1ifIURgfY70MldGkBrK1xquqaAuyi0K46iyqvhZdMLodnD3RhV08CPck0wn4vpoeDWDUpAo/LZeuxidEJCUhiVMPqKpJ1KYkK5HImArCUvOEpkG1X0pRsqIDq6xRF1CXKayVmvQ+yXVpkLVks1jiVdU15RKEddRZVXosIzx7owtaOo7+DeDI9/Hn18fqlhgjCDBKQxKjEaHK64ZJWpu855VJyKhFAj3zJm5gWL9kmUvLGzqQpmVAB1dcpiohLVMR6ynMfRDJ5VVmyWKxxvJ1czOARhXZYZ1VeCy/JTBa7ehK623b1JLCypZnc2QQ3JCAJLpzoaa0iRsdocqqr9ePCs06w/B5gn0tJbwxFEgFksaPkDavQ432OZEIFKqG0j6hLVNR6ynofRDJ5VViyWK1xop1c9OARhXb00FZ5Lbz0p9LoSaZ1t/Uk0+hPpdFc5VUJCOchAUkw4UTLPlWWDbPJadtbh7Bq7icQ8HkcdynxjqETYn3N1HNRV+fDKwdeLyl5I4KV0JN9jkRDBcxK+6jCLLZR1CUqaj3lFdz5TN6spiHZ22H4fVWWLFZrnMq6pryiUHWdRdU1WnkI+bwI+72I64jIsN+LkI+kAMEPPTUEE070tFYVo2M2OXX1DA5PTk67lFjH0Kn+2sCRkjdXtF6CFROXKa2PaCT0ytUbXa+0j9l1ppJp9MYHmUIKWGIbRV2istZTVsHN+sypsmTxWONE6poC+p4MHlFoR51F0WuRxe9xY3o4OOL9mmd6OEjua0IIEpCEJSLlWXhRGaNjNjlFwrXDk5OTLiWeMSyHyCoseWMXTjxHVlhdZzabxdYte3BgTwy98UEE6wM48eOkJrdBTCxLbKOMS9QJ6ynrM6fKksVjjePt5GLuyeAThSO8AAqKdMt2pZEpar5q0pHWj3rjQhAikIAkLOEtzyLyklMZo2M2OZ15ysThF7aTLiXWMXRSZOUnx0y9M7FPKlo/2g1va0me2EZRlyiv9ZQXnmdOpSWL1xrH2smFxZNhVXxbxgvAEnrC25VGRVFzj8uF1cdHsbKlmepAEkogAUlYwloWROYlpzpGx2hyuuq8GYjFDlt+T7VLiXUMnRBZxZPjoWgEtbNOtcVFXkil90YXaS3JE9to5hJlWXTlrafZbAopLca8QLMqUcX7zKmyZNnRI1qVJ0PEC8AjOnlbaqosau73uClhhlACCUjCEtayIDIvOdUxOkaTk6doP3ZMYnqwjqETIqt4ctQ6OqE5EIcoW+YnlcrYWupIpLWkSGxjofWLZ9HFu0BjLVHF+8yptmSp7BGtwpMh6gVgEZ28ReEB+4qaE4QsZL8mmIiuXYfw8hXwNkcAtxve5gjCy1cMlwWxfMllU5bHWDUpggXjw2j0e+EC0Oj3YsH4sFSMTn5yshKFrN+TwWoMgaMiSw/ZWoqA9eSY1fQFlCpYxqCYbDaLFze/h/UPbMfjP3kF6x/Yjhc3v4dsNqv03PKtJfUwai2Zj23Ug6XcS37RlReg+UVX/OAmqe8CR0tUdfdpyOFoiaont+weeQ2Cz5zf40ZzjV9XPOatpCy/e5XkPRl6sHoyWCyyxbD+rvJF4WNaHDnkhovCb9i90fB8WKzcBFEOyAJJMGFVFkRF54bRHqPDWlpFpmi2Fapc5KLB/CL1HHnjEkURbS0pGtvIY1nitULxlqhS9cypiNWTQYUnQ8QLwCQ6m8NCLTUrpeUkQRRDApLgwqgsiMqX3GiP0bEqrSIislhrRsq6yFUJBNbyMiJxiazojVm+heQHe2Lo7Rlkai0pGtvIs+jiXaDxlqiSKdQ+Yt8KY/XMMHveZWM0RUItWH5X3YJF4e0oak4QKiABSShhtL/kZMpniMIisnizRWXjEJ0SCHlE4hKtMBszt8eDhctPQvjiWux/P8YVb8kb28iz6OJdoImWqBIt1A7IxeqxJpWwPO8qPBm8FlmW31VDxiXcUlN1UfNiVHT/IsYeJCAJZdj9kgP4u7PICj9ei5tVxqtqRLJFiyfHQCSC2lmzLd2V5Qjmz8cl6olIo7hEK1jGzOf3SrWWVF0bkneBVo6uJyJhLLxJJTzPu4wnQ8QiayU6RYvC59954einEVZY1BxQ1/2LGJuQgCSUIdq5gUUU8lrajIRfpHkN1zWxWtxYM15VIpotWjw5TpjaglhfcnifRvdCRZwrL6JxiUY4UWfTrtqQvAs0p7ueiISx5JNK8uSTSgBg7bTzR3xX9t6JWNl4LLIsopOnKLzpO88gY5sX3u5f5fDEEJULCUhCOUdeLOOQ7oorE4W8ljYj4dfe5kdN81Km6+ARAvmM1zz5jFcA+PzyaUzH40U2ISY/OXoCAeQyg9auwTIF8+fjD99v60KiX2OKSzRCdMx4Jk5VtSGL4V2gqSxRldU0DB46jGzGa/h75rWSJjNJrqQS0XvntJXNTHTyFIW3uyMVT83McidHEZUJCUhCKXaIQl7Lg5nw6+nYifGNi5hWz6xCgDfjVRUqa0ay3AvROFfWsAOjODi3242Fy0/CvCWTpetA8o6ZyMQpWxvSCp7vAnJ1Fnkt/zxW0l7OpBLR553HyuaUhc2ypaYDlnKemplOxz4T1QEJSEIpdohCXsuDmfBLDvUwu1pZhQBvxqsZPDGUsgkxeTIc94JHILCKD9Y4OJ/PIxWXCPCPmcjEqSKhrFJchbxWMB4raUMgxJVUIvK8s1rZKs3C5kRHKtbuX1TInDCCBCShDLtEIXenDBPh568JM7taWYWAaMZrIaIxlCrq9yVjceZ7wSMQWMUHTxycCljHTGbiFE0oqyQhI2MFY7GSiiSV8D7vrFa2SrOwOdGRirVmZjlin4nqgAQkoQy7RCGv5cFM+IXHz+BaLbMIARUZr6IxlCrq9/mbGrknKyuBwCo+eOPgVMA6ZjITp2hCGa+Q4a1KwIMTVjCepBKA/3lnsbJVooVNlXfBCpaamVTInDCCBCShDDtFIa/lwUj4tUxbja7uAeZrYhUCMhmvKmIoZer3eQQnKzPxwio+eOPgVGI1ZiITZ/GY8MQr8ggZ3thEEZywgvEklRTC+ryzWNlSWg/3QiF/nzP19jU8sLMjVR6WmpmjvcYvIQ4JSEIZdopCXsuDkfATLX9hJQRkMl5VxlCKwnMvWMQLq/jgjYNjgbUotRU8E6cKQcdj8VSdoau3GHDKCgZYJ5XIYGVl41koFN/nQ9EIamedanqfRa3EqroDsZyHVc1MJ2r8EtUHCUhCKXaKQoDf0sabsSqLUcarmahREUNZCOuElU/YCTXUct0LpoxtRvEhWlxZD96i1CywTpwqBB2rkFGZoWslfJ2wgqmmOBHNysrGs1Aovs9aRyc0g/usykos411QdR6iIRnE6IYEJKEUJ0RhJWFl7WIRNaq6hrBnPY9M2Ik21mLWlOYjCTsW94JHvLCKD944OCPsSMZhmThVCTpWIaMyNtFK+Bb+nus9afSZ1IEsN1aJaGZWNpaFAu99truOI+tCUeV5OL0gJyobEpCELVSyKFSReMBq7WIVNSq6hrBOFMUJOx3xQeai5zzihXUxIRoHV4jdyThmE6dKQcciZFTFJvIIIncggNpoBInOfsv9lquvskwxf5aFAs99trOOI49F0Yl6ksTYhQQkoYRKqVtnRi6Twd4HHkbny9ukEw9YhCGPqJHtGsI6Ucgm7IiIF/aEB7Y4uFQqU1JQvJzJOCqTTViEjKrYRNVZ1jIdX2QXdaqK+ZstFHjus50Z7DwWRScy6YmxCwlIQopKqltnhSpXDqswFBE1ol1DmLOeJRN2nEysKCabzWLrlj3Y19aFRJ+GYH0AJ37c0rCcyTh2jImVq1BFbKLqLGvevsqAujhB1YloegtinvtsVwY7r0VR9XnoLd6IsQsJSEKKSivAa4RKVw6rMLRD1BjBnPWsIGGnXIkVW7fswZuvHhz+nOjThj8vXH6S0mScR3b8Etv2v86cjOP0mKjI0GUVRCwla3j6KheialGnKhHNakFcfJ8DkQhqZ80uuc92LbR4LYqqzsNs8eY2aXRAjG5IQBK6sLiUKrEArxEqXTmswlBlhrEVrBOFioQd1eVFWEilMtjX1qW77f22LsxbMrmsyTjlGBNAPtbYTPjylKzh6aucR+WiTlUimtWCuPg+T5jaglhfUndfdiwqRCyKKs7DavFGjE1IQBIj4HEpVVOLK94Xr5n7kkcYqhI1LLBOFMUJO5Hw0SxsM0qKZAuKF5F42YFEEgkDF2WiX8NAIomGxtqyJ+NYjUmlxQqbCd+O9b9gLlnD2le5ENXxeWaJaCw95nkWxPn77AkEABwVkMUuXtWLChGLouzihmXxRu7ssQkJSGIEPC4lVS2u7GzHlof1xcuaXc0qDFVkGBdiNlbsWc8jE3amnNCM/t5Bw2OqilOTiZetC/oRrA/oishgKIC64NExlSlKbVcyDu+1Oy00i4Uvr3WQta9yIarj8/QS0bweF3OPeZkFsamLV3FFClGLouh5sC7eiLEHCchRSH7yyWb4C1DzTBqyLa5Ut2OzKh8SXbsOtTV+dL78iuGLl9V9ySsMZTtt8IwV60SRT9ip8XthVpxFVZyaTLysz+fBidMiI9xoeU6YFlFmARGNW7WycLFee6UkpYlYB1n6KhdiV5xgYSLa45vbmEv7yCyInXTxOh0uwbN4I8YWJCBHEcWTT/feRvhDJzFPPiKThkyLK1XChLV8iMvjweRrrsK4VefrvnhF3JeqWrBZWWHtLkpsdl4q4tRUxMsuWDoFwBG3WaJfQzAUwAkfW3lUwRu3alW8GuC7druT0lit/SLWQZa+ysXYmXzEW9pHdEFcLhevU7V2nVq8EdUHCchRRPHkkxyKIznEPvmITBqiLa5UBtDzlg8xevHKui9F3I4slkWRsVLlAlUVp6YiXtbtdmPh8pMwb8lk4VIiLGVI1kw9F3V1Prxy4HXLuFWW4tWs125nUhqvtV/GOmjVV7kQO61pIqV9RBbEY8HF68Tijag+SECOElRMPjKTBm+LK1XCRLR8iB6i7ksZtyOLZZFnrFS7QFXFqamKlwWOWER4J2SeMiQetwdXtF6CFROXmYYnsFq4WK/dzqQ0EQs2a8kaPXjrBdphTRMp7SOyIHbKxetErLgRKhZvxOiDBOQoQdXkw+JSYi2wbIYqYSJSPsQI0bI7om5HVssiz1ipdoGqilOTjZdlwWyCFYlRswpPYLVwsV67rMg2isMUtfbzlKwZPlYF1QuUKe3DsyC228WrOlY8j8h7XGTxRoxeSECOElRZeMxcSqwZyiyoEiYi5UPM4C27I2P5ZbUsMhd8tskFqipOTSZe1gyrCdauGDUeCxfLtYuKbKs4TFlrv1HJGj2cSCZhKcmTR0WPeRbsdPGqjn9W+R4nxjYkIEcJqi08ei4lkQLLZqgQJiLlQ8zgza6WsfzyWBZZxsouF6iqODUW96CIm85qgrUrRo3HwsXqGhUR2VZxmCqs/dlsCtpAF7JZd9mSSVgSloqR7THPil0uXpWx4nlUv8eJsQsJyFFE8eTjrwkPZ2HLIltgWQ9VwoS3fIgZhW4dluxqGcsvjxWWZaxkrdBWiTf5RUVW05Ds6BC+X3ruQVE3HcsEKxKjls0kkdJiljFwvBYuK9cobwweUxymhLW/MKa2PdUHj6/eMKbW7mQSloQlI1h7zPMmn6WSafTGB4cFo2oXr+pi63a8x4mxCwnIUUTx5DNh4kR0x/Rf6LzYVWAZkA+gFykfUoyoW0fW8strhTUbK9FzyWUziLU/Z5l4Y1csFiDupmOdYFlj1PKC6aNd7yE5FLdMQrLLwsUag0svHkQAACAASURBVMcahylq7eeJqbUzmYS3JA8v/IXej8R6HtgTQ2980LZYT9XF1u18jxNjDxKQo5D85OP2+AGoEZCiGcpOwlM+pBgZt45MbB+rFZbVMiJyLu1tzzCJBLtqUcq46VgnWNYYNdEkpIDPg0iDD5lUL7JZ59oUssZhilj7eWNqeZJJeBM4REry8MB731XGepqFbagutl4N73GierBdQC5duhTjxo2D2+2Gx+PBhg0b7D4kYQOiGcrVgKxbR7QWZiFGlkVeywjvuWSzKfR06F97oUiwIxYrj4ybjnWCZYlRE01CUlE6ibfsTR7eTGMea79ITK2VUBe19IuU5GGF976rivVkteirLLY+mt/jhPM4YoF89NFH0dQkVr+MqBx4M5SrBVVuHZ7SH6wWGFGLGOu5ZFL9SA7pX3uhSFAdi1WIrJuOZ4I1i1ETTUKSKZ2kouwNbxwma6KSSEytlVAXtfTLlOSxgve+q4r1ZLXoqy62Plrf44TzkAubYIY3Q7nSMMokddKtw2OBsbMzSR6PLwR/TRjJodJrLxQJqmOxCpF106maYEUEk+w9UuEKZY3D5O5GwxhTq2c91RPqspZ+u0ry8N53FbGevBb9bDaFDA7DG2nk/s0XLxiq/T1OVA6OCMirr74aLpcLl156KS699FInDknYCG//Z566bXZglUnqpFuHxwJjZ2eSPG63D+HxM9BxoPTaC0WC6lisYlS46WSTsUSSkGTukeqyN1aZxiIxrGYxtbzWU1lLv50JSzz3XUXhcFaLvkx4hNWCgfc9ThDF2C4gn3jiCRxzzDHo7u7GlVdeicmTJ+OMM87Q/W5jYx28XrEXQjRKwb96lHNcMpksHv7NTmx76xA6ewYRDdfizFMm4qrzZsBjkSV9pIxKH3yB+o+TgcT54J3/1HUx1tX68YlPXQAA+ErzOtT9xYdX299A10AMkbomzGmZhS/NvlhZcV0tncTO2C7dbW/HdqG+cS0C3qPXms0E0L23Udc66K8JY8LEidJjAwC55tUAgJ6OnUgO9cBfE0Z4/Ay0TFsNV8G1R667Bvtq/Iht/xO0ri4EIhE0zT0DJ151+QgLlui9G//Xf4WMpiEZi8Pf1Phx4eojpJJp9PdpCNUH4PPb99qKNK9Be5vfcizyyNyjWNdhJPqNXaE1fh+aIuPkLuhjMpqG/W+8rrtt8I2/oOnaK0eMdyHjx6/VvafPPf2WrvW0ttaPcy48pWQ/9ekAInVN6BwotWJH65ow5bhjRzz/ZrQwfYsd3vt+wSWnorbWj7a3PkJvzyAawrWYdsoErDzvZLgZKkBk6v04FI1A6yjNLA9EIpgwtQWeQIDp3WXE3gce1l0w1Nb4MfmaqyzPUQaaj0sZjWNiu4A85phjAADNzc1YsWIF3njjDUMBGY8PCB0jGg2hs7Nf+BxHKzzjYkef1cc3t42IWeqID+LXf9yLgcGkYd021b2cs9kUug+9qbut+9Bb8DcuGrYwnNuyqqT/caxb7JnUo3OgG10D+laHzoEY9hz8sMQi4A+dhORQqWXEHzrp4xJN8ln20WgINc1LMb5x0YjEmy6daw9duBbjVp0/4lnpih35nrJ75x0H9CUBJIViBGWf5ZrmpZhx0ip8dOiQ6VjkEb1HqVQGwZCxK3QomVL2Xkt2dEDr1Ld2al1d+Gh3+wjrrZ5bOhqNfHw+GlKpDN7+y4e6+9v1lw8xa26LriVuRtN0vDBQau0+uWk6+uJqnmdR9H4DHR/GDZ+l0886Hss++ynsfz82PE7dscPMx6uddSo0HYt+7azZiPUlkc0eZn53FZPVNHS+vE13W+fLr2DcqvNt66dN83Ep1TwmZsLXVgE5MDCAbDaLYDCIgYEBvPTSS7juuuvsPCTBiV21/UTrtqnu5czrYrTTrSMSaylaIkhERLEm3hi5ilXfO4AvRlDls+z2+OFjDA8QvUd291AuhDWG1UywFyKaSMKSwMFbzFsl+d9ALpNBx/pfWD5LPr9XuHC4VdiGTHiEnUlvBJHHVgHZ3d2N66+/HgCQyWSwevVqLF682M5DEpzYVdtPpG6bHUkjqnqEq0Ak1pK3LI+dxb7NsOPe8cYI2vUsWyFTxomnh7JoqR+APYbVTLBfdNlpw38XTSQxS+BQ7X2QwYlnySr5S+bdZWfSG0HksVVAfuITn8Cvf/1rOw9BSGBnbT+Rum12JI2o7hEui2gJDVbrYLlElB33jsfKpfJZZun7rIfVPdKzrLHVp5Qv9QNYW7ysBHsqmR7+LGs91bP022HBFsGu96JRMqGRRV/m3WV30psT8BabJ5yHyviMYex0c4jUbbPLWijTKYYHlheenSU07FwQWGHHveOxcql4lnn6PvPAYlkzq0+pquuJlcXLSrD3F23jsZ5a4UTJKj30rLqq34uZbBZPbtmNHW2diPVpaKoPoHVaFJcunQqPxQJA5t2lsgC5FYXiWBbRYvOE85CAHMPY7ebgrdum0lpYPDHkXYzhUBY9/WyWJVaXocgLz45Yy3LGPdlh6eWxcql4lu2ygMnsV3WpH8DY4mUl2EP1AfT0Dh7dD4P1lBVVFmzW+Ekzq67q9+KTW3aPWEh392nDn42SCfPIhEeoLkCuh544Pmv2cThv/iRLcWyETFtZwllIQI5h7HZziNRtk7UWmrv7fAjUheA+bJ4Nx+syrJQXXrnjnoQTfkwmfVYrl+yzbJcFTHa/qrqesNRitRTsBuWTzKynrMhasHnjJ62suqrei6LJhMXwdLkq+d9AALnGZnQlNDS4M0pr8eqJY6tKG2bIFpsnnIUE5BjHCTeHVYHjQmT7Sqtw9/HsQ/SFJ5ppapZdXe64J+6EH4ZJn8fKJfMs21W0XXa/sl1PeN2nKt3SPMhasHmsvCxWXVXvRZFkQpXIuM+tUCWOC1HVVpZwBhKQYxwn3BwiiKy4WSYGFfsoFDC8LzzRTFPW7GpVE59MLUXWe8cz6bNYuWSeZbvib2X3K5uswus+VemW5kXGgs1j5WW16qp4L4okE6pE1H3OssC1Qxw72VaWkIcEJAFAvg2cU5gJG5aJwQpelyHvC080Ho41u1p2QeBUGSA7kyZEnmW7svV596vnaha1CspYiMwEux1NBwBx7wOvlZfHqiv7XhRJJlSFyP3nWeDaIY6dbCtLyEMCknAE2X7YLMJG1t0nsg+eF56oaBLJrhad+JwqA2Rnn2/RZ43XAsZaZoRlv1auRhGroGoLEWtxbVl4vQ+8Vl4nC7gD/MmEqhC5/zwLXLvEsWipM8J5SEAStqIqBodF2KiYGET2wfrCExVNotnVvJYi0TJAIhYpO1zGss9aoQXMLFufN+uexbLG4mrkTVZRbSHa9/Cj0osLO6yXItZjJ2M9RZIJVcB7/0UWuHri+KzZx+K8+ZOEz9vOUmeEWkhAErYiU8IiD4+wUTEx8O6D9YUnKpp4s6tF3dC8QlXG3c0z6bMmHKl41vLnZpatL5p1b2RZk3E1m1lBVVqIspqG2PbSewWw1RiVDY2wEp681uNyxHryJBOqOh7P/RdZ4OqJ45Zjw0r6PtvZVpZQAwlIwjZUZenxCBsVE4PoPgpfeHoTnmicHW92tagbmleoyrq7rSZ9nngsOzJC9bCjzIiIq5HVCsrrPjUSpOneXmid+sllLDVGRZ8VVuHJYuXVuzYVJYiMqIROKjz3X8Yr4LQ4JioDEpCEKTIuJ1UxWCL1DVVMDCL7sJrwRDNNWbOrZbrR8AhVFV1vrCZ9nngsFc9a4bMO6E+WdpQZEXE1s1pBWd2nVoLU29CAQDQCraNUpFvVGJV5VniFp56VlzfkQFb4qe6kItMDncd9XmltXwHxcmeEM5CAJHRRkY2rKgbLzvqGyUwW/ak0Qj4v/B65umiA9YQnmmnKml0t242GVaiq7HqjN+nzxmPJPGt6z/rh+WcieN6akmfdjjIjvK5GESuolYXISpC6AwE0zZ2LQ89sLPlfq9+gTAyvitacrGJblfBT1VhAVQ90gN1C6FTbVytEy50RzkICchRgxypNRTauyhgs1QXPM7kcnj3QhV09CfQk0wj7vZgeDmLVpAg8LpfQPnkmPNHOElbZ1bLdaFiFqshxeLKjeeOxZJ41vWf90DMbER5KljzrdpUZ4XE1qraCsgrSE6+6HINDSe7foOgzqWKRwiO2VQg/lSEOqnqg8yDbyIEFlvnKrraihFpIQFYxoqs0qx+wqpU/oK6EheqC588e6MLWjqOTcDyZHv68+vio0D7L2Ys6jyprrZVQ5TmOSHa0SDyWyLMm8qzbUWaEx9Wo2grKKkhFf4Oiz6SK1pys16ZK+PGKe6NFlaoe6KLGBZnWiUawzld21ogl1EICsorhXaWx/oBVCiHVJSxUFDxPZrLY1ZPQ3barJ4GVLc1C7uxy96LO40R7Sp7jiGRHi8RjiTxrIs+6nWVGWFyNolZQIzHBK0hFfoMiz6SKxRDrtamy6rIez2pRJdsDvRJdwKzzlZ01Ygm1kICsUlhWacWw/oDtEEKsMTgyAeOs9KfS6Emmdbf1JNPoT6XRLCAIVMdqiloPWCxFhfsWheU4MtnRovFYPBmhMs+6TJkR1kQNo+/xWEGtxIQT3T9ErZfMyWMGvxXWa+MV0fmEq0y9WGMBq0WVbFOESnMB81gV7WorSqiHBGSVwrJKA46u0nh+wHYmrRihMmC8ED0XUcjnRdjvRVxHRIb9XoR8pT8LVjGnwvqnynqgZynS23cyPhOBprOFLRNmFimZ7GjV8Vh699DpZ501UcPqezxWUBYxwSpIZQuB81gvs9kUMul+RC65xFB4svxWWK6NVfgVJ1wdikZQO+vUEcmFVsdjXVSJNkUohwvYqoIBj1WxErPBCX1IQFYpvKs0XreAU27QPLwB41YTmZGL6IZLWuH3uDE9HBwRA5lnejg4wn3NK+bMLC2sk6+d1gO9fXcceBHBwaQtlgkVmfiy8VhW91DvWY/On4fgeWuG96Gqgwprogbr96ysoKxiwkqQ5jIZ7H3gYXS+vE26jaHVYoznN8fyW2EV2yxCszjhSuvohFaUXGh1PNZFlWhTBCddwKwVDHjnq0rJBifMIQFZpfCu0nh/wCqTVqwmX56AcdbyQkYuorpaPy486wSsmhQBAN0s7EJExVyhpYWnJJKd1gOV+2YVVHb1y+XB6h7qPevHtETQ2dmvpJxVHtZEDZWZvLxiwkiQqqjKwCoMWX9zvM+zldi2En68CVdGx2NdVIk2NHDSBcxawYB3vnIiG5yQhwRkFcOzSpPpgiKatMI6+fIEjLNMZGYuom1vHcKquZ9AwOfB6uOjWNnSbFgHUpXg4pl8eSd8HsuYCsuEiKBSlYkvAm/oRvGzLiKcjOJ4WRM1VJbpUSEmVFVlYBGGPPfLLkubkfBTlVzIu6jibWjglAuY97kQsSrakQ1OqIMEZBXDu0pz2i3AOvmyBoyzvrDMXERdPYMj4u78HrdhwoyKCYr3Jcs64YsIORViQkRQqc7E50HmHvLeO6s4XtZEDZVlelSICRXCiVUY8twvOy1tegszlcmFdi+qnHjX8z4XZFUcfZCAHAWwrtJU/IBZLV48k6+PMWCc9YVl5iKKhGuZO+ComKB4X7KsE76IkJMVE7KWqHL0y5W5h7z3ziqOlzVRQ3VWtKyYUCGcWIUhz/2yw9JmtjBTlXCVT+y7eMkU2xZVTog10eeCrIqjBxKQYxCRHzCvxYt38mUJGGd9YZm5iM48ZSLzi1rFBCXykrWa8GWEnN6+myeegkDT2ZbXUgmF0gthyYyXuYc89441jpc121llsXJeMVE8riqEE6sw5L1fqi1tVguz4oSrQCSC2lmzmZILRQrqm8GymGd51wsXGy9DtQ6isiABWQWoygC1wqwGI6/Fi1c4sQSM87ywjFxEV503A7HYYeYxkJ2gRF6yVhO+jJDT2/cxxzShs7Pf8lqcKpRu9bzzZsaL3kOee8cax8uaEWxHsXIrMWE2rtG161Bb40fny68IVWXgEYY890ulpY11YVaYcDVhagtifUmm/YsU1NdDVWKXinJhLBUMiNELCcgKRmUGqBlWsVsiFi/R1anP50Fd0G8oIlnLCxnF3XkMOsyYjYHsBCVaEslowlch5PT2bWWJsNviwPq882bGy4gM1nvHW/iZtQg5S5keVS5Kq3GdfM1VGLfqfOHFLKswFLlfxc+zyLjwLMzyCVeeQACAtYCUKahfjIqMeEBNuTCzCgbE6IcEZAWj6kVhhVXslqjFi1c4sRQT5y0vxBp3ZzUGMnE7qvt4qxZyuWwGsfbnmCwRdtYHZXneZTLjre5hYdH5PKz3jjWOVxUi1iOjvssAe2crkaoMhcflEYZCoTYSVjU7LewyBfULUZURr7pcmIoWs0T1QQKyQlH1orCCJXZL9MXKK5x4iomrfGHx1KGUQeU5qxRy7W3PMFsiVIvhPKzPux2lW/Ri086afRzOmz9pODaN5d6JFn4uhqXNIY/1iCX2jrezFQtmx/Ux3CMRK6KMVc1OC7uKgvqAujhk6jdNqIAEZIXiVMICa+wW64vVqF2c1bmKijgV8aE8dSgB/onNjhhWVUIum02hp0O/aLWZJUK1xYH1ebejdItebNqv/7gXA4NJrtg00cLPeVjbHPJaj1hi75waV5aYP1Erogqrml0WdlUF9VVZSanfNKECEpAVilMJC6yxW1YvVtmAbF4RpzI+lHUMeK/RiRhWWSGXSfUjOaRftNpJSwTr8666dIvK2LQ8vIWf87C2L+SxHrFeH8+4miXb5ZEZV1Erogqrml0WdkBN7UdVVlLqN02ogARkhSLyomBxfRXDGrtl9WKVDcjmTUJQGR/KOga81+hUDKsMHl8I/powkkOlRav1LBEqkzYK4XneVZZuURWbJgtP+0Ie6xHP9VmWj8pk8eLm90xjlEWOW4iMFVGlVc2OmD5VBfVVWUmdbCwhMjcRlQ8JyAqG9UVh5Pr6SjPbC4UndkvvxarCdcSThGBHfKjVGPBeI3cXE4dKNRXjdvsQHj8DHQdKi1YXWiJUlPywgvV5V1m6RVVsGiB3D3naF/JYj3iuz2pcN/3mbeYYZdFxlbEiVotVTbagviorqRPFxlnDMojqhARkBcP6ojByfdX9xYdzW1ZZHkc6dovzpW+0GmUVsrzxoYUTO6BvhbAaA95rZD1Hp0o1mdEybTUGBpOmlggZCzOrsLJ63ov3Y5Wly3JcFbFpKu4hb/tCVuuRyPXpjWsqlcG7b32ke+56Mcqi4yprRXS6XaseTi0GVVlJRStMsIQysIZlENUJCcgqwOxFYeb6erX9DayYuIzLnS0Su8X60rdajbIKWdZ4Ob2J/fD8MxE8b43hxG40BrwTG+s5VoKb2+X2mFoiRC3MosKq+Hnn3Q/v9/Vi086afSzOmz/JeNAKUHEPedsX8liPVMTeDSSS6O0Z1N2mF6MselxZK6Iqq5pIqEYlLAadgKXcGsAXlkFUJyQgbcSJuA8z11fXQGyE68sMmdg21pc+62rUSsiyxsvpTeyHntmI8FCSW5zxTmws5+hUqSZWjCwRom5FVeKYdz+839eLTWs5NsxUDFnlPRRpX8hiPWKNvTOznNUF/WgI16I3Xioi9WKUeY5bjAoroqhVTSZUoxIWg8WwWAl5YS23xhOWQVQnJCBtwMm4DzPXV6SuqcT1VYyq2Darl77q1ahVvJzsxK4n/nknNqtzFC3VJOMiS2ay6E+lEfJ54TfoylOMiFtRWcFjgVhS0eOKxKapLLdlR/vCQoyuj8Vy5vN58MlTJmD7H/eV/L9VoXTecXUiNs8I0VANuxeDvL95VishLyzl1vLwhmUQ1QcJSBtwMu7DzPU1p2WW5QSkop0VYP3SV70atYqXE53YrcQ/z8RmdY68pZpkXGSZXA7PHujCrp4EepJphP1eTA8HsWpSxPT/ADG3oiphxbsfp+qn5rGj3BZrm0NVsFrOVp53MgYHk9KF0llR0Z6QB5lkQLueO9HfPE9TBh5Yyq3l4Q3LIKoPEpCKKUfch5Hr60uzL0ase8Dw/1S3swKMXUd2rUaN4kNFJ3YW8c/rHjM6R95STTIusmcPdGFrx1EBH0+mhz9fOb7e8hp4ra+qhBXvfpyqn5rH7v7gdsNjOXN75JLtRBHxkohY6WUywO167kR+83Z21uIttyYSlkFUDyQgFVOOuA8j15fH7TF9kapuZ2VmIXB6NSpaR9NO8a83Pqyla2RcZMlMFrt6ErrbdvUkoGWylufO61ZUVvCYcz92Cjqj35Kd/cHtRsRyJppsJwqPl0TGSi+TAW7Hcyf6m+dtysADb893u8MyiPJCAlIx5Yz7KHR95TIZ7H3gYXS+vM3wRaqq8C6rhYB3NSpbDkNvYo/On4fgeWt0v2+X+DcdH8ZSTTIusv5UGj3JtO62nmQavUMpuAzOnbd0TiE8wsps8cEr0FQLOitRYmf3EuBIVxfRwtNWbl87LGcirmaj3zqvl0TGSi+bAa76uRP9zfNaCXkR6fnuRFiG3SEORCkkIBVTKXEfLC9SVYV3WS0ErKtRVeUw9Cb2Y1oihtm1dol/lvGxqukmM9GHfF6E/V7EdURk2O9FQ40PfQPJEX9XcQ9YhBXL4oNXoFl9n7c6AqsoUd29JJPN4sktu7GjrROxPg1N9QG0Tovi0qVT4bFIhGBd1Km0nIm4mq2eMx4viYpEFpkMcNULCdHfPK+VkBfZusGqcaLJAaGP55Zbbrml3CeRZ6BoEmNl3LiA8P/awacap2IwraE/2Y+htIbmmkbMmzAHa6aeC7cDD3RW09DxxM+RHSwtuZHu7UPD4iVweY+sHWpCk5HNDCGTOoxcVoPHF8a45lkf//iM7FIFx8qmEP/gOeSypavdTOowgpHT4HKVujXG+eoMM9I7f/kEejb/bvj8s4ODGNq7F9mhQYw7ZZblORXj8nrhGTcOLq/X9FnxuD3oHorj/b4DJdvmTZiDWdGThz9nsymkk71wub0l11eIyPgYXUOquwtDe/eWbKs/6ywET201/F+P24W4lsYHh4dKtp3WXI85LU0lY6LyHhSOfzHxg/+FROf24fHJZTUkBw4imxlCbf1U5v2wHDeTzeBX7z2Dp9r+E8/tfx7bP9qB7qE4PtU4teR3mX9OeH5Lqln//HvY/Go7BrUMAGBQy2Dvh30Y1NKYOdncmsMzrnXTZyA7NIh0bx+y2hC8Tc2oP+usIyKuQKhavWd5jpnH6jlzub04HHtT9/fj8YVRP+Gs4d9PKhZDbONvdI+T1YZQf9YieMaNMzx/AHC5XKitn4pg5DSMa56N+glnoa7hk4bvwsIxSWaSiA31wO8PwB+ql34uZH7zLSc0IqmlMZhIIpXMIFQfwCdnTsCCpVOY3usseDxu1NT64PHo/3aAI3NRKhaDy+u17Xci8tyxvr9VUWkahYdx44wXQWSBtIFyx33wuD5kS2Yoj6Msc21EKzc772pX5fjIuMjy2dYsWdhO3QM7krjMEKmO4HRWdx4tlcGOtk7dbTvaunDxkimG7mzecVVhORO5l6zPGauXRKU7nidUw86ybaK/+XJbCZ0qqs773JG1Ui0kIG3E7rgPI1ecyItUtPCuqjjKPOWasPNYiX/eskdCNRQNYnlkJnqPy4XVx0exsqXZsg6kU/dA9eIDMI6lE02QcjqrO09vQkPMIBEi3j+E3oRmWFtRdFxlXPAix2R9zljdyuXKiOdZmPAW9pYV9/mEp2w2hZTW61h8oEgsqkgMI+9zp6psHXEEEpBViGVLQIEXqWgAsqo4yjx2Tdj568tm2F6+euJfxMrCMz48cWuiE73f40azhTXcKdGkcvFhZfEQTZAqlyhpCAbQVB9At46IbAzVoCFofFzVizoWRI7J+pzxeEmczojX0mwLE9nC3qK/+XJY3DKcHgyZc+R57pz2eIwFSEBWISwr3ujadait8aPz5VdMX6QqXjC8gedmYlX1hF18fd17G+EPnST0AhW17LCOT6WsjoUWIAIZ8yoXH1YWD5kEKZWihHWhFvB50Dotis2vtpdsa50WMc3GVr2oY0HkmNwlmhi8JHZnxBcTH+plWpjYUdibJRlM1TuF5/edjMW5PBgy58jz3Nnh8RjrkICsMlhdcS6PB5OvuQrjVp1v+sNX8YJhtRCwilWVE3bx9SWH4kgOiYkyUcsOy/hU2uqY9R7Ixjqp6HvMEkvnDwSEqyOoECUiC7VLlx5JANjR1oV4/xAaQzVonRYZ/rsZKsaVF5Fj2mUxVJ0Rb0RjTYPlwkR1YW/WmEsV7xSR37e/qZHZg6HiHFmfu3JY5kc7JCCrDF5XnNmLVLVosbIQsIpVVVYEO65PxrJjNj6VtjpmvQcydfcANX2PWWPpZLtiyIgSkYWax+3G55dPw8VLpnDXgSxHP2mRY9plMWS19Ir0hi8k4LUu29bbN6i0sDdrzKWKd4rI79vDYVlWcY6sz105LPOjHRKQVYbKWoVOihah+EHGCdvIvWLH9clYdswmNd7VsUxxaR5MFyAKs7ULxTVvPC5rLJ1VglShS1AlsguZgM9jmDBjhWhynAwix1RlMWS19Jr1hvdwlrmxWpioLOzNkwwma3GT+X2zWpZFz1Hv/af33BUvEMphmR/NkICsMlQWKnfSpG+HmLNyr9hxfSJWFpZJjXV1LFNcWjWqs7VF43F5Y+mKE6T0XIJnHn8qzjl2pXQZFqDyrMusyHaCEkXGKshq6TXrDb/6+KjpMQoXOID1wkRlYW8eD5SsxU3m981qWeY9R9b3n9kCwWnL/GiGBKQA5Xqx5mF1xWU0DcmODmU/XkDc8mWHmLNyr9jpsuCxsrBOaiyr4ye37B6RWNHdpw1//vzyacLXI4LqbG2ZeFyZWDo9l+Bv2/4bAwMpw/qQPFRb7JXRwixy3TW2HlfWKshq6bXqDb+ypVlXuOotcJLxmQg0nQ2Xy21atk2k/Z8evB4oGYubit93oWXZyRP+uQAAIABJREFUyLPAc46s7z+rBUI5LPOjERKQHDhVHNUKqxVv/jz3v/E6tM4u0/Nk/fHKWr5UizlW90rx9flrwsNZ2E7A4760sm7KFJe2A5UZ87JuXtFYOtH6kDzwPPsq+/mKLnSNFmb7avwIXfj/2XvXGLmu60x0dVVXVTfVTRb7IYpS62VZimXqYSU2JUUJpJFlIYRF2SObjn2BwDYTOxlfX0yQPzeYCwS4HgQJbpAfQYD7x4DiYKBcI8IYiSJFxsBOBrHHkuUAI9Fy5KFlPWgmlLub/WA3u7qq+lTfH+Shqk/ts/d67X1Ode/vny12V/V57PWtb31rrROi72SDRBUEwCu9rt3wa90t46grU4Izf+a7MNHqILqFdQZ7UypQ6f1vzv47aDIUN63321VZwFZ1sOcfN0GIoCMSSAKkDQPayMt4Kd8T+/JqKF/UbNg2pgJbXsn+fdccPgznl8yG9hSaCjOnfJmXHUuGS7vAJS4U5c/2GVplXqqXjjsfkgrXs685r0+S6NoSs6WXfgBXHXvcS9VFI+hjlV7XbvjJ2mBY1GjI6yQdWO2uwYH9k1ATCA7ObVm2+0+0ZGh0yWMrCy5VEHv+cROECDoigUSi6BV7WHC/p+3l1VK+sGQVM6aCWl5J/75KtQ4A5kPIh8KsWb6UDJfOw/Z2D37247+F8+d+yCIuGOUPQ46KKvNqNqXZvHuuZ19zBqgk0bUlZu3FxVzfG8a3aLO/aAR9rNJbr1bg9ubEDrUzxe3NCeP3lyQ4WqsO+xMwWwVKU+iQdslrTsLAnn+cBCGCh3glkSh6xR4WPr6ntvLlyjQxYyp8bAjxoTBrlu4lw6XzoEVcbMof5jOKGrGh0ZRG8e6Znn3NICtNdG2JWWNmZiAxw/ztGPuLVtDHVjkou+EBZAkOZwd7P2wJ2MC2LE9CB7dLXrOBDHv+cRKECB4igUSiqJ24VPj4nj6UrzxQPGmqG0I8KsyaoyMkw6WzkBIXTNmb8hnS68S1HphKgvfecKkLG4NQ3j0MpAmkLTGbOvqhgeuK+dsx9hetoI+tclB2wwPwExwNjy0lySub0CEh3ibFGnv+UROECB4igUSiqJ24VHC/p40M+FC+8kDxpGkOIfZ58GoOdZYMl86CS1wofj3KZ3Cvk9R6YGpKu+6aaVhYWHP+bEjvHgYaCWReYnbzyc/C4tLGlX+H+du3e9to+ws16NtK4tguW8xu+BSmBGf68B3QmHoo92ekHltqkse5/z6ninCIt0uxxpx/1AQhgodIIAnwtXZLG+n3aZ16BdqLi9bviSUDFOWr203YnYYcT5rGEOIQCrPm6AjJcOkUXOJCUUQ4n2Es81qCnJb1wDaGJQ8hvXsYaCS6eYlZloxj/vaktYW2v2CDflGzUE0JzqFDU9ZEQ+qxpSZ5lPsfaqoItbKAUayx5x8lQYigIxJIAnyt3dJG+j2nvvh5eOf1s9bviSUDmMyv1+vB9/7hp/Dm6UVYv9CGif0NuPnyrLMK8mDXHJROwbAozJrgEBeqIiIlR64gV3RzW2jvHgZaia4rMcP87dvVKtn+4gr6Rc9CpSSC0vOMk4Bh73+oqSKUykLZRpVF2BEJJANaa7d8o+r4nhwPnC3z+94//HTHtoX1C+0r//tXHrkV/b2pO4u1ZudRA2+odYI+cfC6R2HfeB3On3sVRVw4ZW8JOXIFuaI9XyG8e9QSY6hEF/W3V0HV/jKMBEOyg52TgGHufxGJF4Z4+xxVFqGPSCD3MDTN+91uAm+eXjT+t7dOL8K9D74HXc52DUpPoTk7DwAfeMu0TlCKkZEKXP++j0H94K+iSDhHEeGSI0yQK0NzG9a7h0l0+oOstMQYItHF/O2ajV/DSDCw51keuAmY7f6HSLw4CXbIhs0IOSKBDACOSTnEukRN8/7GegfWcw729bU2bKx34MDBcdL3c3nSNGfn9cMVeIsuofkAtiwnKUlTyRE2yPmwHrjWgPbD5d3jJjo+S4ySfdP9wPgWNRu/NAkGxautUeXgeGwB6M1lmO/qM/FKkh781bdOsxLskA2bEXJEAukRHAUh5LpETfP+vok6TOxvGEnkxGQD9k3QvIuuQ1Bzdh4Fw1JC81le1/DrYcgRNsi5rAeU4E9ZA5pFnnePk+j4KjFq7Js2XUtMs4JG45cGwaB4tbWrHBK4kjzKd/Xp+X7y734kSrA1FesIv4gE0iM4CkLodYlcMpBVMGq1Ktx828wOD2SKm26bQZevsYegZvmdglAlNK5CFKK8Lh1LhCVH2CCXZz3Y3u7B0tlvkoK/9vvHTXR8lRi5MyulG4s0ISUYFK+2ryqHD1C/K7fZypactrsJvPjqOePPYRNsqmItmfoRIUMkkJ7AURCoP2PbFY0FlQzYFIxffvgWALjkeVxfa8PEZANuuu3d/x8DdFc4ofzer5pI4dujI1WIQpbXuWOJKOSIEuSy1gNqQPWh+nETHR8lRsnMyjIRKUlJnOLVxpD/soCTqFCbrTDJ6ep6GxZWWsafpybYLsVaY+pHhAyRQHoCR0HA/ozWblWAneSqhiADLgXjVx65Fe598D2sjJByCGLK7yY1s7N8JzSmHmKrJtQSGtXLKtlqMizldQo54nYUcwKqD9WP6zP2UWLkzqwMYRfhqEickjjFq40h/wD6VQ4OJBUZbLMVJjk9MNGA2eY4zC8PkkjtJhitqR8RfEQC6QkcBQH7M9LdqgA8bw9WwajVquSGGQD6Iegqv5tUk/kz34WJVidXNcEEMkwJjeNllW41GZYOVQ45onYUcwIq9Z3FJAcSn7FLfaVWILgzK33aRbRVJJffleLV5pB/rZFiVGg2RJqATU4btSrcd8dheOY7bwz8O80mGM2pHxF8RALpCdwg6foZjd2qALySlGTrBsbTRz0EreNhiKoJJZBhSmgcL510q0lRIzA4QdP3VifWBhzkO0tNDrg+4zz1Nekl8I3Tz5ArENyZlT7JiZaKhE2IKV5tCvkvutlGsyHSBEpyevL4Edhodbw2wfiY+hFBRySQHsEJkq6fke5WBeCXpDgKBsXTxz0ETV48qmrCCWR5JTSul0661ST0CAxJ0MSWprmKDvdZwqwBpSYHVJ9xVlnMqq+SCgR13zSAP3KiqSJREmKKVxtL/jU8otLRbZrbjLKgJKfVqt7YpjxIp36EGJO3FxAJpEdw/Fuun5HuVgXgl6Q4CgbV06d1CFJUE+1yCNdLp7HVRNKhSu381giaeaVpDjnNkk3Os+RaAypptHE1HWG8zdIKBHbfdBaUjUXYEVJaKhJ9vWYF7dXGkH+pR1RrdJt0OoINnORUY2xTHrhTP0KOydsLiAQyADgbIfJ+RmNXtKQkRVEwOJ4+rUOQoppwAplNGZN00GKvbx7Z43SoJr1tePbtBVLnt+/GCgo5tZFN7rOUtwbU5wYPjLKoUYEAwM1t7AdmYxF1hJTW7FhuQkzxatvIv9QjSlW0XeqZ6btqeDPLNp+RM/Uj9Ji83Y5IIEsGjDFeslsVQFaSoigYEk8fd0RMP0wK1PThO6Ax9dCOf0cJZBhlTNJB67q+WEsAJft/+sdnyZ3fnKCJ7bSlklMX2eQ+S6ZA7WuDB1ZZ1KhASGC7ltQRUlqzY303kPj8fIqizVpMoejN1NwopAGKkgxQzP7v3Y5IIEsCymge6W5VAHmpGKNgSD19KbAlsey/M6mZhw5NwcLC2o6fowQyrDImbRLJu76SMT8mdJIevPxzs6Jl6/ymzeGkddpSyKkPJXQ7SeCNrz4JCy+8OBCoOckBJinEKoucCkQIvxd3hBRGRXJdP98NJK7ER/L5FEWbo55JbSamSodGaVpjhnEKrJIcYv/3XkMkkCUBxxhP3a2aLWP48su8+/1knj5sScz17zAKFCaQUcgKd36hDdIxPyasdbdgqdU1/jebSkwJmtQGJQo59TFixhWosckBJSmkKIvYCkRIvxd3hJRNRaJcPx8NJJTEh/v5WEWbtZhCkFxJFxrkgTrDWGtnO4Df/d97FZFAlgBao3nyYCtjaJSKbeB0fabAlsSopTOTHwhTDuGQFY7/NQ/SMT8mJWWyNgpT4zU4byCRLpUYEzQ5DUoUcqpdvsQGakxyQEkKKcoitgIR0u8lHSFlUpEo189HAwkl8eF+PlbR5qhnkuRKu9KRAntPfRBYn/u/9yoigSwBtIzxeShyDRm36xNbEqOUzjD7fG3lkKK9VlxLgE1JqVcr8IFDTfj2W4PX0KUSY4Imt9MWq+holy8pgdqWHHCSQqq32VaBCO33onTpYiwp3KSakhDbSvvcyQychByjaHPUM+555aPScen34u+pLwLre/7sXkMkkCWAT2N8iDVkGOR5+vL8RdiSGKV0JiXSvr1WLnAtAS4l5cT75qC10WWpxAD2oMnttKUoOpTyocsPSAnUts5WTlKIURaxfsYi/F6uLl1Kl7bPpBpT2g85qBpjd2EtpmCeV9JKRx6w99QXgQXwYy3ay4gEsgTQGM2TB59ryCRw+YuwJTHsv9Mi0hyvE2fPbx6olgCMklKt8FRiDKSdthhFB0M2sX5ATKDGdLZKkkKTskj1Mxbh93J16VKsJpzrhx1Vgynta40Y6oezGchhd+GoZ5zzStL82Gu3oXXuIvSS0QFihr2nvghsPzStRXsZkUCWBNLRPHkouuyaB5cqhi2JYf+dFpGmKGOSPb95wZBqCcAoKSmoswGx4MxrS0HpILaRTYofcPbEp2F8rA4LL3zfGKgxSrZ2Ukj1M/K6xXkNC9ln1dSlS+3Splw/yqgabGlfa8QQAL1xJA+sxRQMbyan0oFJcLD3VGt6hwtxG40ckUCWBBqjeUwouuxqAtZfhB1ci/l3tLEzbiUDo4xx1iNigyGW7PlQUqigzmsD0O0gpvoBR6pVeM8XTsJVxx4fCDAUJVsrKeT6GdHd4syGBQpx43RpY68fxZpCKe1LEp9+SFZP9qP/XCIvpiB6M6mVDmyCg7mnGhu5bIjbaPQQCWTJkGeMxxjP84iPzx2pHGD9RdjBtZh/hyHSmkN3uSZ87YYnTSVFCsrmD80OYq4f0FTmoijZWkkh9/tjFStuwwLlWeV0aaM8oURrCqW0z0l8stCYsKF5LmFBqXRQEhzsOyGZ3uGyDMVtNHqIBLLkwBjP8w6YmeknAMDPiAvJaiyqKoYdXOv6d659vprkjbse0UfDk5aSEgpcxS2vJKXpB+RYQqjzWge+o/D727vFeQ0L1GeVs0s5he36Ua0pnNI+JfHJQqMZyMcUDawvG1Pp4CQ4rneCM70DYxmK22h0EQlkyYExnucdMGdP12Fs+uEr/7+rjIFROTWy4aJUMds+X23yxikd+2p40lBSQoIakFwlKc35b0VYQnzOr+M2LHCeVR+7lDmEntOMwvXLSSdsaJ9LEl92Hnw2bFF82RjLUNxGo4tIIEsMjPG8Vu3lHjAr8z+Cqw/+qvOAoYzX0MqGQ6pi/Yc/wKSRSGuTNw5JJvk0GQEtVVJ6vS5026tk9Vhz/ZgN1ICEKUlpzn+TWkI4987X/DpuwwKHuPnYpcwh9JRmFKlfTtpMpX0ucXzZLpRhQDfWMhS30egiEsgSA2M8P7hvM/eA6WyuoA4Y7HgNzWw4hCpmOvwv3n8fTBx/YuDw99GtTiXJKJ+mIKC5rA550OoizSJP8aYEJGxJCkMa+st6NnAtIZJ752t+HbdhQaLE5llNuLYYLqHHjHLR8MtJmqk0zyWuLxsDSYKj0Q2NtQyVgezuJkQCWWJgjOfVai33gKmPNZ0HDGW8ho8Sq8Rf5ILp8D/37HPQ3OwMHP4+SpMckuwKhpKAhrU6ZKHVRXrlcxGKNzYgUUtSJtJgKuu9/+5r4Z77r7eW9aidrRpkRDq/zhSsuQ0LWs15UluMD483AC45AXATOEkzlea55HM4en+Cs7+6BRcMcyCz0OyGpliGQm+j6XYTWFq8CN1uUmrrEAeRQJYYOON5NfeAaV59xHnAUMZrhJgpifFhprApFhyztCQg2r4LhSTbgqHEAG5Tj21WBx972jGKN1Zx0yhJmcp6L33nTWi1OuyyXhZFm/dtwbparbIGyWsRNy1bDGeNoA2Y5ATmcNuaAPjNVFpEPcRIr0qjAeOzM7C+sOb8t5rd0BTLUKhtNDsS08sVKKnftGyIBLLkwBjP8w6Yudseg8XzG9bfTxmv4bOBgOLDxCgWHLM0JyD6GrFhCoYSA7hNPbZZHahdpK4yJHWgtEtxk5akfJb1+lG0eR8TrLmD5CXErSyrVk0oi19Oi6hrNS9Skvw8+EioyJYhz9tofPhNy4ZIIEsOjPE874AZQfjTqOM1JNmwbXQEZc0ZRrGQHP6UgOhjxEYeJH+TTT22WR2wXaRYIs0ZKO2CpCSlWdazNRkVSUaKVj9tKOuqVYByNIfs+D4KCqukeZGS5LvgI6Eq07SJUIlp0YgEckiAmYWIPWCygY4yXoOTDbtGR1BUKaxiEeLwl6on1KYByd9kU49tVgdsFymWSHMGSrsgKUlplPUwTUZFkpEi1E/ss13WVaspQvvlfENCsihJvuv++0yoOL56DVW1Hz79pmVCJJBDDGr3mi3QUcdrULJhl5RPUaUoioXp8J+9/16YOG7vOsaCq55Iyt6SgMa1Ori6SClEWjJQ2gVOSUqjrIdtMpLcO0mAC6l+Up/tMq5a7Ucov5wGKAlprVaFsYk6LCOfKWySv73dg5/9+G/h/LkfWu9/WdRdTVW1H2VYIRsCkUAOIbjda65Ah934YkJeeRoj5VNUKYpiYTr8D83NwALC4I0BVz2RlL0lAY1rdXB1kVKJtEvx7iQ9UjOHFKay3u2Xu7BdoDQZce4dJ8BliUTIYM15tsu2atWUmPv2y0lAJe2cZwqb5FPufxnUXYqqSkGZVsj6RCSQBYMz+4zTveajmxbAXZ7GSvlYVYqjWGyN1mBtfxMmR3Ufd8530WoakAQ0rpcqr4uUSqTzfL3J9jY8+/aCcZxMdWSE/H2xMJX1rr22iUo0OKvqKPeOEuBsRAITrKVlPO6znZfY9Npt6AZU/TTHyoQElbRzSBMmyafe/6LVXWpDHxXDtkKWg0ggCwK3jMk1xGvsZDXBVZ7GSvkUHyZWsUi2t+H5M4s7CMkvLh2Eh2YOqBESqnpS5qYBLrhlyKzi/fyZxR0DrZc7W1f+92M3zip/60voV5tqjQbZlyRdVWcDNcC5iEResNYq40mf7TSx2U4SmP/6Uywixx1GDqA7VgZAZ0C28zOIpI1LmjDWk257lXX/MQkVJbnBbszy0dDXj/7EdKxeg81Od9cojykigSwI3DIm1xDvI9BhO80wUj5lzRm2kcdESL791gK0Nrq5hIQagKhNRWVvGsiDq6wsLUN2kh68trJu/G+vrazDo3PTxs/lBmkttUm6qs4GSoCjNJdlzwetMp7Ws80hctJxWpqd6iGVTCppl5AmV5Lv42yjJDfUjVk+GvpMqNWqMDVzlZp1qkyIBLIASMqYXEO8j0CHLU9TpHyKD9NWiqUSEmkAwpaFy940kIVJxTWVlaWz6ta6W7Bi2McMALDS2YK17taOGYXSIC1Rm7JJhmRVnQ2UAMdV/zTLeBrPNpfIScdpaXaqayuZNlBJm4Q0uZJ8H2cbJbmhbszy2dC3VxAJZAGQlHokhnjtQIctT2vN56KUMaiEhBuAsOWSfnDUOklpLgvKdaSWlbn+ysnaKDTro7BsuGfN+ihM1nYeVSICyFxRZ0syuKvqbKAEOK76o13GkyrRHCKn4SvW6lQPPXOTSto0SJMtyT943aOwb7wO58+9Km6IoiQ3XI8/xToVMYhIIAuAVOrndq9JdrKaQO004+695ni0KISEE4Co5ZJ+UNQ6zU03edfxy5+6x/jvuWVlDurVCtzenNhBVlPc3pzY8TnSIM1dUedKMrir6mzABjiu+sNRpGzJjFSJ5hA5DV+xVqd6ETM3qaTdJ2kaGanA9e/7GNQP/irq/tssKJTkhuvxp1insNBM9suOSCD7EOrGS6V+afeaZqCTdJphx7VwPFoUQsIJQNRyiQkYtU5z003eddw3XoePP3DTwL+nqrhSHLvhEmkzlcv7IQ3SHJJS1Mo9SoDjqH8URWq7l8DS2W+ikhmuEs0hclreO42xMlIlkxODyD5sD6QpC9f9x1hQKMmN1OMvGWF35W+yJPu7FZFAgr99xjZozD7Tmk0mGd/BKU9jfXXpd+N6tEyE5BevvdSF3Q9qAPI1EikLKmmxZfO26/jiq+fg2NHrB64jtawsRXVkBB67cRYenZu2JhbSIM0hKdQkQ3uzBSbAcdU/rCJ19vSzpGSG2+BEJXJa3juNsTJcJVMjBlFJuwZp4gJjQaEkNz6b2bCwJftXX33C++cXgUggIew+4xTSUo8GNKfwU8rTFF+dxKNlIiTXXXNgoBuOGoB8jUTKAktaMNm87TourrSM15Gi4mqiXq1YlU2NciOVpGCTDF+bLSigEgmMItXrdWFl3pw0ZZMZaYMTh8hhE3KMZ1mamHOUTB8xiKJmhhg51P9ZWAsKpdzuq5kNA2eyn3S8f4cisOcJZFGlqRTcUo8NqfoxecBO6HxN4beB6qvTGLXgIiQANEVYUi6hHNRY0oLJ5m3XcaY5nnsdsWVlE/K2E2lAWm6kkhRsklHEO2UCpxRqU6SS7hp0Ns1JU1aB1epCphA5V0Iu8SxTQX22tGMQRc0sYng6xYJCKbdre/wpcCX73fYFACjnCkwJ9jyB3E2DnbPqx+zBcbjrlmmj+uF7Cn8eqL66UKMWKIowp1zCOagxpAWbzduu4313HM4/lJFl5X64thNpQGuLBYWkuJKMot6pfnBKoZikplqbhPpYEzqbg0lTfzITugs5i7yEXMOzTP4uyGdLOwZR1EwO2ZfaMzgWFEq5PevxD6GuupL9WmM/wEVzBWiYsecJpMSAzRnh4hNZ9WN+uZWrfviewp8Hjq8u5KgFrCJMLZdwVRkXaaFk83nX8eTxI7C0dNH692JU3BSu7USaoJYbJcHElWQU9U7t+BwCeaAkNZVKDZpXH4H5M4NJU78CK21w8hHsQ3mWudAcwE1RM6lkn2rPyFPBQ+1mD6muOpP9ah0AIoHcdeAYsEOWQ7Cgqh9aU/ip2SjHVxeia5AKSrlEosq4SAslm8+7jtUcRZFTBsVuJwoNzWCSl2SE2myRB2oplJrUzN32GGy0OlabB7fByWewD+VZTkElwZoDuClqJpXsY+0ZmG59jY53F0IOdAfQaYwdNux5AglAv/FFlENcoKof0tKwpFmA66vDlDFCz+DCjETSmA2XR1o42bzrOko6QrHbiUIjRDDxbbdweUop5IGT1IxUqk6bB1dd8nl/fO4r74eEBGuRD4qaSSH7FIEC063vsqBIlegirBRlaIwNjUgggXbjy1oO4agfktKwpFmA46tzoYhRTFhobbnIg3Y2L+kIxW4nMsGXVylkMPFht8B6SinkQZLUuGwe1OfR9/0JNeJFQoI55MP0vlDUTArZxwoUlG799Dv0P2daSnQRA91T+GiMLSsigewD5saHLodgwVE/uKVhrWYBiq/OBSrpCTm2wrfnR6uhBEDeEUrdTgTg36sUMpj4sFtgPaUU8uAzqaE+jyHuD8WzzKliaJFgTAxyvS8UNRNL9rECBaVb3wQtJdp30h5xCZFAEhGqHMJBVv2Yab7bhW0DdaBsGZoF+kEhPdtJAvNff0pEVjjkM4TnR2OwvEZHKHU7kUbQsAX9IoKJ1pBmqqcUSx5CNDJgn8cQ9wfjWZZUMUImKa73haJmYsk+VqDAduubwCHhebaOUI06ex2RQBJRhon3eciqH7fcNA1rqy31zym6WSALCul588m/ZJMViVKmqRL2A7sOEguNjlDKdiKpcoMJ+tRg0kl6MH+xDd2kZ72mIVRsqqeUQh5CJDUA7usUMtjbPMsS60aoJIXyvrjUzOx9cRFcjD0D261vAoWEY2wdoZ7vvYxIIBkocuI9Bqn6MVYfhTX3P2f9fkmzgPaAaSzp6bXbsPTSYHkPAEdWNJQy20FNKZ1R1kFSoNkRitlOJFVusEEfE0yw1zTkeBCupxRTCvWV1KSgXKeig73UuhGKBGsondznF2vPwHTrm0Ah4Rhbh+/nOyISSBaKnHhfFnCaBXwNmMaSnq3VVWgvmMuBrsPXp9GfUzqjrIOkIuQ4ColyQwn6mGCCvaY+O4azqhDHU0oFxfpAUV0p10kS7DUSUg3rRggSrKF0Sp9flz0D061vApaEU20dGtaeCDMigRQAM8Jlt4LTLOBzwDSG9IweOACN2Rlozw82ALkOX27mjxk2Ty2dUddBmtBPBAB2lqU1xlFgiYZEueEE/bxggr2mvhIJmypE9ZT6wHaSwBtffRIWXngRpVpxrxOJzCompBrWjRCKl1TpDDmRgNONjCHhZR0V5gshGz6piAQyQgRss4DvAdMY0lNpNGDq6FE49+xzAz/vOnypmT922DyndEZdB9kPE1G5eP99MHH8CeP2EWoA4JTHuMqN5gYP7DX11SzhUoWwnlJfoKpW1OvECZLchFQ6/sYFLcUrL/mUKJ1FjrfBAEPCJaPChglF7CmnIhLIIUSZM5I8hMoaXaTn5pOfhdZmh3z4UjN/7LB5jorGWQeZwkQEzj37HDQ3O9byFXbjEKc8xlVuqEHf5jHFXlNuCdH2zmJVIYyn1Ac4qhX2OnGDJCch1Rx/4xOu5FOidA7LeBsbCafYOqR7u4tE6E06HEQCOUQYhowkD6IB04rbZSSHLzbzpwyb56honHWQADwiQNk4JC2PcZQbTNDHeEyx15SaSGDeWV+qkFaHPuf7Ya8TN0hyElLJ+JuQRASbfHLel90y3sZl65BsSisDitikw0EkkEOEEBmJL3WTNWDa43YZzuGLJZ+UYfPc0hlnHSSHCFA2DhVRHsNYF7Ae0/5rutrZggM515RSQsS8sxRVCPN+anfoc1Ur13XXbmj5AAAgAElEQVSSBElqQsodfxOaiITYdFZ0x7sGXKPCJJvSyoCyWw1SRAI5JPCdkVDVTY4qSG0GkMxl84mUfHaSDqxunB/wKFGHzXNKZ5x1kFQiQN04VGR5LM+6QPGY9l/T2uQYdNc2jdcUm0hg31mMKkR5P7U79Lmqles6SYIkNSHlfhaViEgT8BCbzrhVGM1KkBZMtg6tTWlFYlisBpFADgl8ZyRYdVOiCpIGTAvnsvmEy6NEHTYv6XqmrIOkEgHqxiFpecxHmZDjMa1XKzB7VQMWNjoAkB84XSo25Z11qULY91OjQ9+E2ROfhvGxOiy88H2yapV3naRBkpKQcj4LQ0RSaNmLQm46w1ZhfFaCfKBsm9I4GBarQSSQQwKfGQlF3aSognmBF9MMoDGXzRcwHiXOsHlO1zMVJqIye/+9MHH8iYF/y9k4xCmP+SwTSjq1pYGT8s7aVCHK+ynp0LdhpFqF93zhJFx17HE1iwsmSNp8nJSElBOQMURk7vL/1rIX+dh0hhklZgPpzG+3oXXuIvSSUfTzoa1slm1TGhfDYDWIBHJI4DMjwSolWFVQI2PVHNHCQd6hhvUolXXYvImoHJqbgYWFwZ1FnI1DnPKYT7+SZDyL1ELBeWdNqhBFyZR06AO4g7n2UOa8IDn1yV+HZ99eQPk4sd3p1ICMJSLa9iKtTWfYUWI2oM98hgLrS9mUbkorC4Zhk04kkEMEXxkJVinBqoIa3kXNuWwp2t0Ezi1ehKSb5B4irkON6lEq67B5LBHgbByi/P4QfiWOx7SXdFQsFK53FqMOUZRMbod+UWXKvCD57NsL6puWqAEZS0S07UVaySe2m9sG7JnPUWB9ety551YZUeZNOpFADhGsZS5BGQCrlGBUQU3votZcth0l0rU2TE3ml0hdh5qGR0l7FzgG3OeDs3Fo4LMtjQUh/Eocj2m3fYFkoci7vnnvbNJL4Bunn0GpQ1Qlk9OhX3TDWn+Q5Po4saVaSkDGEBFf9qI0+ez1utBtL5HeXa1ubtSZz1BgOXGC4pHWOLci3IgEcgjRfwDalAMKMOomRhXstpfUvIsaK/UA8CVSzKEm8Sj52gVug5ayhN04tOOzEWWtEH6lfgJbQz57tcZ+lIUCe32zpIWqDlGqD9QOfUnS52PsF9XHKSnVumZlYoiIL3uR5N2lVEpsxBtz5ndW58kKLMXjLvFIc86tCDy8E8h/+qd/gj/8wz+EXq8HJ06cgC9+8Yu+P3JPwaYcXH31CfTvwZZ3XKqgD+8iprkk7xCklEixhxrXo+RzF3geilSWMGUtil+JqqJKOmMr1TrKQsG5vhx1iOOHwnbocxrWfC41oPo4OaVa6qxMFxHxYS+SvLuYSgmWeLvOfI4CS4kTPj3Sw7jVrUzwSiCTJIGvfOUr8Bd/8Rdw6NAh+OQnPwkPP/wwvPe9w+dDKCOcykHSIf9OV3nHpQr68C7a4DoEKSVS7KHG8Sj53gVuQpGjkChlLVeZkKvESDtjXYGTe31DzPqjgJP0+VxqQPFxcku12rMytRsepO8uplLy9OlnUMTbeeZzmsWQccKXR3qYt7qVCV4J5KlTp+DGG2+E66+/HgAAPvrRj8K3v/3tSCCV4FIOuu0LAOAnq7KpgiF3yrrUB0qJlEp+KQ0yGrvAqeM4ihyFRGkscJUJOUqMRmesK3Byry/HR+sz4JF3igdYs4b1cXLIuK9ZmQD0hoe8d1rj3bVVSjjE23bmcxRYTJzw5ZEehj3TwwCvBPLnP/85XHPNNVf+96FDh+DUqVM+P3JPwaUc1Br7AS6aXz4KqDK/lnfRBcwh2KjVSSMdsOSX2ggj2QXO9XgVOQqJU9YylQm5Soy0M7ad9OD8ZueyN84cOLnXl+Oj1Q542YYEStInvbYYKwLWx8kh41SPpZcB9453WuPdtVVKljZWVFXwfgV2f3ULLhjmQGbvOyZO+PBID8ue6WFAqZpoDh7cB6OjvBd0dtbvXMCyorN8J8yfGQxE04fvgEq1DrOzdUjabegsLUN96iBUCS/GdpLAm0/+JSy99BK0FxahMTsDU0ePws0nP0tQPd4NvO2tDixvrsLBsQPQGJXPRHxnfSH3EFzeXIHqRA9mJybhy5+6B/aN1+HFV8/B4koLZprjcN8dh+Hk8SNQNQSlq68+Ab2kA932Bag19kOlL5j0kh78t7/7F/hfr74DqystONAch1+44xp49Pj7oeJQLd5/97Xw0nfeHPj/b7/7Wrj22mbuz33tf/61UWXdt68Gn7vnU9bPtD0fhw69e2/63x/u87ITk3Dx/vvg3LPPDfyX2fvvhUNz+R3B/WhvLMLZ7gXjf0u6q9Cc7EFj3+C7n+yvw7nZGWjPD5a/GjMzcM1754x/W9Lbhqd/fBZefvUtWGp1YWq8Bh841IQT75uDamXQG4e9vln89vSnYd8rNfjns6dgcWMJZvZNwQfn7oLfuPsTA0lB0m7D26deNv6e1qlXYOqLn0ffpyTpwZN/9yN48dVzsLDSgtm+d8H23KeYnZ1kX9vtXgJnTz8LK/M/gs7mCtTHmtC8+gjM3fYYjCDnEppw340fgL8//Y8D//+9N3wArrtmkATtT3ow9fq/wflWd+C/TY3X4eZrD0KjWrFeq/5zgxN7MO8099ky4TrYeR32bzVgZt8ULGwMJniz+6bgluuuZZ7Rl65Ffy0Fd9/z/54H7r4OnvnOG4b//1qYs5ybeWidu2hNgPZXt2B8Fnc+UbAbOYpXAnno0CF45513rvzvn//853Do0KHcf7+8vMH6nNnZSeMg5L2AxtRDMNHqDCgHjamHYDtJ4F/+36+yy17zX39qh+rRnl+Ac88+B63NDkn10Bhoa/y9SSVXfTg41oRkvQILrUvPxccfuAmOHb0eqvUaJJ0uNGpVWFq66PiExmUF993s97vf+smORpjV5Ra89J03odXqOBth7rn/emi1OgOr1+65//rc57eTdODFt83k4ftnXoaPHP6wtZxtez7Sz0zfH+0y6cTxJ6C52Rkoa00cfwL9vvZ6FajW9ucqMStrFahcNP+u8bs+AG2DL2v8rrth6UIHAAY9wtn5g+dbXfj2WwvQ2ugavXGY65uHj84dg48c/vAOdWjp/OAZ2Jmfh/aC2T/bXlyEd14/iy6b/tW3Tu9Q4+eXW/DMd96AjVanryFh8LkH2HnOcq7t0tlv7iiTdzaXYf7Md2Gj1RE1dP3atY/CxkZ3oFT7a9c+mnsPfmHyKvheazD5/IXJfXDh8rmAuVac2IN9pyXPFgZHpm6H/74xSFDfP3U7XFgevP9YZK+J9L4fv/8G2Gh1BjzSx++/gXUdesmotTpyIRmFdWU+McwcxUZ8vRLIO++8E9566y342c9+BocOHYLnnnsO/vRP/9TnR+452MoAbz75l+yyl6bMrzHQ1gRqKbBRq8LszFXGFxlTVpM2wlBWr6WQNlxQ7ATaZVKNxgJJUxbVl8XxxkntGhgfrdacQc2GBOq19dnQxWlqc3ksfQ64x77TkmcL45fW2nhjK/Fr3HftmY7Dsmd6GOCVQI6OjsIf/MEfwG/91m9BkiTwiU98Am691c+4kqKhvc8zD3kHQ9bg3Gu3YemlwaALgCOAVJ9Tnk9Sa6BtHqSHIKXDV6MRBiB/9ZrpGdIYXA7gHoXkwxfU7xOVbFLgNmVRCaxkj7Tt+kpHhVACXqih7dRrG6Khi9LU5vJY+hxwT32nMWPMUlCqPdKNN3nzGb/8qXve/TeK911zpuMw7JkeBnj3QD744IPw4IMP+v6YwhBqBRi1DLy1uppb9sIY3bGqh6vsqT2yJBsgpYcgpcNX0ghjg+0Zkgwup0BzHZv2wHSpyoftjJXukc5C0xLgCnhFDW3HXtuid9vnIW9Wps8B9z7faU61J494u0SRvPmM+8br8PEHbgKA8t73YdgzPQwoVRPNMCLUoGbqwTB64AA0cozumLIXVvVwlT21FDRXgOTsnKaWV2q1Ktx828wOD2SKm26bYc9xdD1DWqUmGzTXsUkGpru2YvgaOwTA3yOdB01LgCvgaQ9t14bEihCqutMP39cK805Tu7+1qj0YUcRW4n/x1XNw7Oj10KhVg88FpqLMe6aHAZFACqDl63GVuFgzuxoNmDp61NgFi/V5uFQPTNmz3mioZNs+5nZxyiu//PAtAAADjTDp/08F5hmqVmoilRUDSpnURvK4PlFfjVZUpB64/7W2AUutDmqPtAm+RoWYAp7m0HYtmEgf1YoQqrqTB9e16iQdeGd9AZKkQn4fbZUT7uo+rWoPRhSxlfgXV1o7SvxcC0oRiUMEDZFAOmB7iKX+DmyJi3sw3Hzys9AydMFifR4u1QNb9pQqaL6CMae8wmmEsYHyDHFUVgpcCQOG5HF9otxGK+1VZKk37n+bugre/Ldl5x7pPGhaAjQ/i9KQwLm2LtJHsSIUuYYTIP9aJb0Enj79jEqyY3qnuav7NKo9WFHEVuKfaY7vKPFT77t24hDXFfpDJJA5wDzEUn8HVlXjHgwUn4eNKOfJ/Niyp9SnSAmQlMNCUl7Ja4ShwodHiDv42PW8YEgexyfKUdip/kKqmtGoVmB6jK/yaloCfHyWrSEh79rOfOkLzu+CIX0YK4K0ukMd9G9D9lr5mioBIOv+1vBWYhNaW4n/vjsOG78j1oKilTjEdYX+EQlkDrAHIdvXQ1DVJAeDi1BJsj3qOASugoYJkNzDQrp2UVpm0fQIcUtfSbsNnfn5K8+IKWHAkjyOT5SjsGOTr6LKoCFHhWh/Vt61fXOsDpMfP5H7c5qjerjVHe0Grix8T5WQdn9Lqz2UhDavxH/y+BHEjF0zNJ+huK7QPyKBNIDyEHMJCLXERT0YtpME3vjqk7DwwotWQiXN9kKMQ8AEyOzQc+xhwe3w1SQmWrvDqaWvlHS/feplaC8sWkk3heRRfaJUhZ2SfGmWQamlsJCjQrQ+y3Ztl176AVx17PHcv11zZAtXmZc0cPUjLzHUniqRhbT7W1rtoSS0eSV+03YvLLSeobiuMAwigTSA8hBzCQi17EQ9GDDZl0a2hy2TS5U6W4DUOCyoHb5cYmIiIa5nCENcOKUvSoZOIXlUnyhVYccmX1pqBlfd1hgVgn1vtMaS2K5te3HR6t3UtGNwlHnpoH8Ad2Io9Rm67qdW97fEL01NaDXnM2o9QyE9yHsZkUAawGuuoBEQbtkJczBgCZWmYpDnk9RS6mwBsnv+fNDDgkNMMCQk+wxRiAu19EUl3RwbBcUnSlHYscmX1vMtLYVxRoVw3xvpWBLbtW3MzFi9m9ojW6hERmPQvysx5NqJKPczVKd8HqRzVyXQeoaoAk1stOEhEkgDQs2u4pSdMIoENvsKMeRVu5PSFCA5TQQSRZRDTDgkhKQQEktfnAydaqOgHMoUhR2bfGk835qlMEpzk88OZFfDXN61nTr6IeffqmXHAKATGemgf2xi2P8eLG+uwEGEz5ByP7VX93Hha+6q6+zVeIawZ0RstJEhEsgcaB6EeaCUnSgZLJZQ+SbKPvff9oOi5m73Elg6+02RIkolJhwSQv0ZaumLQ7qxJE9yKGNLb5jkS+P51iiFUZubfL032DMk79refPKzsLi0Yf0MH+oVlshIB/1jE8P+96A60YNk3T4Hkns/09Jwt5vA6nJLpaOcO6FBA9jnT+sZwpwRsdFGhkggcxBSxseUnSgZLIVQ+STKIfbfpsCquWdPPytWdqjEhENCOD9DKX1JOnddJC/EoYxNvqTPt8Y4Hmpzk6/3BnuG5F1biiLjcze4DZJB/9TEsF6tw+zEJCy01qy/twwd5dQkxgfRpKrqqHFPlmfJdUbERhs5IoF0wPf6NAw4GezsiU/D+FgdFl74vpVQ+STKKiVExSaCXq8LK/PmERxUZYdCTDgkhKcQ0kpf6bPQOvUKtBcXVbqENQ9l28abFK7kS2OPtmREDqe5yYe1hHOGuK4tlQj6Khdmvwd30L+vikzRHeUA+CSGQjQp919bVac8S3nPcWy0kSMSyCEAJ4MdqVbhPV84CVcdexz1kqdEudduQ2d13vnvMYeH5ED20USQdNegs2kewUFVdijEhENCJMQF2xWZku6pL34e3nn97I57yfWI6pR89dcaShJByYgczlw/H0RGU9XkEkFtZdr2PbiD/n1UZIrqKE9BSWIwRJNz/7VVdY1nKeSw/92KSCCHABJFAtuViT0UqIcH90D20URQrU1CfawJnc3BERxcZaefmNjKPhwSEmqOYLXvGZF2zWscyj42fWDUzDxIRuRw5/ppExlNVZMTvLk+YNv19mGV8FWRKaKjPAU2icESTc5113z+tKocIYf971ZEAjkEoGawKZGZPIDPwLGHAvXw4BzIvpoIKpUaNK8+AvNnBkdwSEpUmLIPh4RozfajQErcpYey9qYPH2omBdy5ftpERkvV5AZvijKNSVJ9+9e0rUuhO8r7gU1iMERzZl/Ved0BzGPutFR1zdJzyGH/uxGRQA4JMBlslsjMHhyHu26Zdq6ywx7GkkObciD7bL6Zu+0x2Gh1VEtUlCYJrCKcVV+wB6JkPJEWcReVfJU3fWiomVLvnmSunyaR0VA1ucGbokxjktRh9a+F6ijvBzaJwRDNrWX3zF2YmzH+dy1VXbP0XESSvpsQCaQnaHcaYjLYLJGZX25Zuz1TYA/jUIe2z/mUI5WqqrLDaZKwgUtWNAa2axF3UclXuOmjH1pqprRUWpa5frYzBHtecYM3VpnGJql7wb8m6SjPApPEYIhmT3DdtVR1H6Vn6QD+vYpIIJXhezBpXgYrITLYwzjUoR1ikLuWssNpkrCBS1Y0PKPaxL3SaMDozEFIumsAvQrqvnE3fZigoWZqlko1V76l4CjO/c8+9bySBG+MMo1NUveCf426EtQGbBLjIpoa113j7I2l53IgEsjLkO5qTlHUYFIJkcEeCiEPbWm5I9RqKm6ThAlcsqJVetYk7hJFlLrxJg8aamZZS6VaK0I55xU3eGOUaUqSGpJEFLnqjttRnqK/gaxRq1uTGAzR1LrukmsaS8/lwJ4nkFoHMUCxg0mlRAZ7KIQ6tLnljtCrqbhNEiZwyYqmZ1TLpyRRRClrDW3QUDPLWirVUJy555U0eNvKhZQkNQSJ8H2e+CSmkgYym1ouve6a1zSWnovFnieQmuNiilQrpEQGeyiEzPx2HK5I9asIBVjSJNEPLlnRLD1r+OS0FFHsWkMbpGpmGUulWtdXel75Ct7UJNUniaCeJ9hKVohE18c4rH5wr3uIM1oytisCjz1NILXHxRStVmSJzEzz3S5sLLCHgs9Dm3u4YhQV04gJF7rdxOpB0mqS4JIVjdJzdoalxCfHUUQ5q9MwhFZDzSzKb5VHRrQU56LPqzyESFJd7zQA7TyhVrJ8kyjNcViaZMx3la7osV17DXuaQGqPiylarcgSmVtumoa11ZbXz/QB7uGKUVTyRkyYQN1Fq9EkwSUr3NJz0uvBV//mh/A/XvnX3BmW1PtBUUSpO3oBeAmGRM0M7bdykREtxbno88oFW5LKLf1S3mnKeUKpZElIFDbR0mgg80HGfFfpfKuuETuxpwmkj3ExErVCq5EnJTJj9VFYY/+WYiA5XLUVFc1dtNiAxyUrXM+oa4Yl535QFFHKDM0URTWqUVR3jqKawkVGNJudXOdV/5lUBkhLv5R3GnueUCtZHBJFTbQ0Gsh8kDGfqrf2EoIIN/Y0gfQxLoZDADQbeULAp/FbkqFqKipau2i5AY9rEaCMyMCMfhph3g+MIsoZPSVJMLQSNBs4imr2O2LIiFazU955tb3dg6Wz39xxJnWW74TG1EPoM4l6vTHniiR5oL7T2POEWsnikChqoiVtIPNFxnyq3tpLCCLc2NMEEkB/52wKCgHwsffZB0IYv6UZqpZfTWsXrSTg+TaCo1aXMe8HRhHljJ7iJBghEzSOotoPLBnBKs5YJTR7XpnOpPkz34WJVsd5JlGvN/ZckfrnOO805jyhVrKoJIo741fSQOaTjPnyFGsuIYjAYc8TSO2ds1T42vvsAxQyhDGpmyDNULX8ahq7aLkBL5QRHDP6qVKriu6HTRHljJ7iJBihEjSNrURkMpJzfSVKqPRMol5v7Lki9c9x3mnMecKpZFFIFHfGr6SBzCcZ0zqjszFGcwlBBA57nkCm0Nw5S4G0kUejnIwpNaH3ZRMbT0zQyFClXeIau2i5AU/Le+S6r9jRT9j7QX0WOaOnqAlGyARNYyuRlq1GooRKziTq9aYkWdLqhOSddp0n1EoWhURJZ/xyGsgoZIzr9+We0bYYo7WEIAKHSCAd8L2BgNvIo1FOppSasGRIo/GkLFsGpLtoOQFPw3tEua+//vB7Yd94Hf7HK/+WO8PSdT8kzyJnhiYlwdCetGCD1lYiqa1GqoRKmgup15uSZGn45zT3S/eDW8nCkCjNZQUUuMhYnsr95U/d4+X7pHDFGI0lBBE4RAKZA22/X54axFUcNDpRKaUmDBnSajxJUfSWAekuWk7A0/AeUe5rtVKBL3z8Tjh29HqnipB3PyTPImeGJiXB8DFpIQ9agV5qq5EqoRIVlHq9qUmWtDqhuV8aACBpt6EzP3/lGfRVydJaVpAHU3xylcDzVO5943X4+AM3uT+TIc5gY4zGEoIINyKBzIHWqBCMGkRVHDSGsVJLTRgytLbcUmk8CQ3XQSbZRUsNeFLvEbdky51hqTUYmPP5mARDWhKmdhJrBnouGdFQQk1n0vThO6Ax9ZDzO1OuNzXJwiQPmOYz6X7pVGB4+9TL0F5Y9L4yVWtZQRaY+GQiYzaV+8VXz8Gxo9fnfj+JOKPV3Bihg0ggDdCclo9Rg6iKg8YwVk5pz0WGNBpPQiJEVzm1HC81gocs2QIUu74TC05JeLuXDIyxwXRu+wr0FGgooaYz6dChKVhYcE+WpV5vjqpoSh5CbiEpahapxrKCfnAbzGwq9+JKy6pyS67dsMWY3Y5IIA3QCopklQ+pOGgMY+WU9lxkiGJS9+0txUAaBCh/A6UcLzGChyzZApR3HV4/OCXhs6efFXVumwJ9iDmUKbBKqOs7cVRQ6vXW8jyH2kKiKTAUeQ5KGsxsKvdMczxX5ZZeO24jlGSwf0Q+IoE0QCso+lKDNMzkktKejQy5TOrq3lLuSjPBQUb5GzikQTJ+w8dwfOvneRoM7COwYslQr9eFlXlzIxOnc1trDiVlNJZLCdWcjZn3vajkU+J55jSfcZ8xDYEhRPUDwH7+SOKTTeW+747DuSRN49pRGqGkg/0j7IgE0gCtoOhTDdIYdeNjiLrLpK7mLRUewJKDDPM3SAJ0f2DjGMF9DcfPg+Zg4FCB1YakuwadTXMjEyfxk86hlIzGyit5aszG1BjZhQHG00hpPpM+YxoCg+8SOOb8kcanPJX75PEjsLR00fgzGteO0gglHewfYUckkDlQmUXoUQ3SKPtQSk3UbN1kUtcs/UgPYO5Bhv0bOAFaizyFHo6vOXaJc1+1y1PV2iTUx5rQ2RxsZKImfhpzKLmjsfLeWa3ZmJq74k2geBopzWfSs0MqMGieg3nAnD/S+JSncler+cmDZsXC1QilMdg/wo5IIHOgFRR9q0Eao25spSZNRUjNW6pwAHMPMszfMDpzkBWgtVWJ0MPxpc8i9b76Kk9VKjVoXn0E5s8MNjJREz+pjYUzGsv1zmpYa7RHdplA8TRim8+0yFsqJLROvQLtxUWSwOC78YySIGjEJ2pjj69VhlloDPaPsCMSSAekQbHoVYlSaJIaLW+p1gHMOcgwfwMnQPtUJTg7tX3v4TaBel99lqfmbnsMNlodceInLRNyxpa43lkNa43vcSocTyOm+Uzr7EgFhqkvfh7eef0sSWDw3XhGOX+KiE+hFkVoDfaPyEckkIFQ1KpECbRJjVb5QusA5hxkqL+hVyEHaB+qBGesSchRKFlQ7qvv8tRIpaoSWKVlQurYEuw7K7XW+B6nwhmoj2k+0yZvVYbAoFECt51XnAShiPjke1FEURt89hJiG1LB6PW60G0vQa/XLfqrDABDaqiYPfFpaD7yERidngGoVGB0egaaj3yEvOd64p5fNP43VudvrQIjB0YBavhd3ba/ISUNJuQF6DSwmcBVJdIS4FJ7GbZh+0oJ8BuvP6f6My5gn3HKfcWUpzRQqdSg1pgSqTIHr3sUJmaPQrXWBIARqNaaMDF7FKVmpmNLTDCNLcG+s5LvxPleWXSSDixsnIdO0jH+99TTaIJpoH7v8kaYXrt9ZfC1STlXPzuY4JyD20kC819/Ct76g/8Eb/1f/ye89Qf/Cea//hRsJ8mOf8c5f3Yrfv3h98IjH5yD6f1jUBkBmN4/Bo98cE5tg89eR1QgCdAcLaI5RsMXfJRatMoXGj4a7j3A/A1Ub5H2OBxOCVBjD3c/ONcXe1+55SlKww3nfTeNTZGWCSljS7DvrEbpkrNXGqtwYz2NHI92KA+eDZxzkGInCj2Joawow2D/3YxIIBHwMVpEY4yGBJjg6GvGX/q7Rd5SBSIqvgcW5ZIToDUDG6cEqLGHux+c64u9r9TyFKXhZjtJ4I2vPgkLL7yIft8xZJlbJqSMLaG+s5LSJWevNKUxBuNp5Hi0Q3nwMKg0GgDTTTjfXoMDyUhugka1Ew27914b2ht8Ii4hEkgEtLtjtcZocEAlw2XI1m3gElHJPaAoa5QArRnYODu1pXu4+yF9xjH3lbJ3mtJww3nfQySE2P3Nod9Z7PeiKtwuT6PUo+3Dg0dpPqP4jbkeaU6CELe2RGARCaQDPrpjQ+8r7gc1OJYpW9eE5B74Jgu2wIYtq3J2alN/xteWCyyw5SlKww3nfS8yITShrO8sV+FOPY1ZlGkPO6f5jKLGhlgZOgxbWzTXgYZcLbpbEQmkAz4OqdD7ilNIyLDvjjkA2qo2EyieNe49KIoscGwUnJ3amJ8JseWCAld5ijIPjvO+S8gyN4hhlBMhTwEAACAASURBVK7sO8v9rPTneomMhGoq3AD+SBXnOlH3cFPVWJ92ohTaY7E0CZpmz8Aw9B8MCyKBdMDHIRV6X3GKMmXs/ZCuROOQK+49KEo95pRVOTu1MT8TYsuFJigNN5z3nUOWuUGMo3RxPyv7c+ffOAj1yVvZgZajitugTaq414nTfMZRYzHWBG4SrjkWa7uXwNLZb6oSNM2qT9H9B7sJkUA64CvzK6JLLkQZhAPpSjSuR5VzD4pQj6U2irwSoA15PxN6y0UeKOoGpeGG875zyDI3iFGVLslnZX+us7kMnU1ZoOWo4jZo+j2514lDBjlqrM2aIE3CNbe2nD39rCpB06z6lM1uMuyIBBIBH6b0IrrkQpRBqJCuRJOQK849KEJZK5NyrLHl4pJK0mJZFbgqEaXhZvbEp2F8rA4LL3wf/b5TyDI3iHGULu5n+Qq0HFU8RSfpwVp3CyZro1C/vG9Zy+8p+Xs5ZFCixprsRNIkXGtrS6/XhZV58zPKfW40qz5F9h/sRkQCiYBPU3roDQAhOjQpXXzSlWhUctVLOtBtL+0gi9R7EFo9LpNyLNly0ev14Lvf+glbJQHgqUSpX/CT/+4m1Dy4kWoV3vOFk3DVscfR7zslGeEGMY7Sxf0s34GWooon29vw/JlFeG1lHVY6W9Csj8LtzQk4dsMMVEdGAEDu0Zb8vVwyqKXGauwl19raknTXoLNpfka5z41m1aeo/oPdikggCQjRSOIbWDLM8dJwuvikK9Gw5CpVrt557SfQ2VwW+XJCq8dlUo4lCqxUJaGqRNK1jJz3HZOMcIMYR+niflaZAu3zZxbhe/PvkpLlztaV//3YjbMqnyH9ezlkUKLG9kNrLzlFpc9DtTYJ9bEmdDYHn1Huc4M9c1CzjUvkzd4NiARyF4CzMSMvOEq8NJwuvnQlWj+xSGFaiZZVN7HkyodxWlM9dqm2FOVYc2OSCRwFVkMloapEHL9gCHCDGEfp4n5W6ECb52ntJD14bWXd+DOvrazDo3PTV8rZEkj/XgkZ5HiU+6G1l1xja0ulUoPm1Udg/szgMyp5bmxnDrWJMm7p0UMkkEMMHxtyuCqRpIsPsxLNpm66yFWZjdNY1RajHPt4HkzgKLAaKglFJdJeyyiBiRxxgxhH6eJ+Vvbn6mPNK13YWnB5Wte6W7DS2TL+7EpnC9a6WzCtdB81iIWUDHJATcJdkG5tmbvtMdhodVDXEWt3sp05808/RZttHLf0qCESyCGG9oYciUok6eLDrERzqZs2clVm4zRVtbWVVTWeB8omDYoCq6GSUFQi7bWMHLjIESeIYZSu7D3kflb25645fBjOL5nfcRMwnfKuysBkbRSa9VFYNpDIZn0UJmt6IWyYiQVnL7kvjFSqzuvIHVqePXNYg//7KjS12DAjQiSQAkgHX0uAeXEAaH4TiUqk0cWXtxINq27mkasy+bn6oTl7TTrqR+oXdEFLJcGqRNpDqznAzsvkJC8mpct1D/m7uC/9XKVaBwA3gcR2ymMqA/VqDW5vTuzwQKa4vTmhUr7OInRjowY4e8n9f6f866g1tJzSRBmqQrOXEAkkA9KZWxrAvDgwN0P6nRKVSKuLzwTpjLKijNMuNU9z9pp01E8Iv6CGSoJVibSHVlNRhG2iLJ5PrN8YWxk4dsOlc8zUhQ1QbCJfNpiScEpVgYt+tdkFzcSZMqFCu2IXEQkkC9JuUg34GO0iVYk0uvhM0FA3U4Wqs/YT6GyueDVOY9U8rdlrALLnob0Vxi+oqZJgVCLtodUUhLZNlMXzSSHO2MpAdWQEHrtxFh6dm94xB7LX68F3v/26t0S+KGKqRfh8VxUAzGpzZ/lOaEw9lDvdQjNxxjZRSis0EWZEAkmERjepBnyNdpGoRBpdfCZoqJupcjU99TF459w5kr+J2tWMVYI0VVvJ87C8uRrUL5hnVdCGyy8oDdQ2j19o20QZPJ8ANOJMrQzUq5UdDTPcRN71PhdVYdImfCEUaZPaPH/muzDR6uROt9BMnAFwEyrKtIxhNyESSCK0Zm5pwMdQcA2VSNrFZwJF3bQF9kq1jjZOczwzVCVIU7XlPg8Hxw4U7hf0iaxfUBqoMR4/LdsENnkJ4flM2m3ozM9bvwuVOHM7nzmJPPZ9LqrCpEn4uFuLKM1DXJuGtt0JM6GiTMsYdhMigSRCa+aWBqy7UdttaJ27CL1klKVGhlKJsAESo25y19zlgeOZoSpBmqotd2NSY7RYv6AU1MAnDdRYj59kLAw1efHp+Uy/y9unXob2wqL1u1CJM7fzmZPIY97noipM2hYEyjnEPTclNg0fdifbhIoyLWPYTYgEkgjtmVsa6H9xhqXTjPs9beqm5rBwrmeGqwRpqrauDSqm0m2RfkEuOIFPGqgpqotkLAwnecHcQ86Qeep34RBnauczNZHHvs9FVZi0LQiUc4h7bkpsGr7sTjaEWOO71xAJJANlmrmVxbB0mml/T+2uV65npqjuXwwxyCvd/vb0p9XWqoUEJ/BJAzVHdaGSI27yYruH3ISN811CzFOkJvLY97moCpPUgpBNCrHnkOTc1LBp+LA75YFboYnIRySQDFB8gr7XymU/i3LYh/xu/fDREcctp+RdA4lnJqSaRyEGeaXbfa/U4KNzxwDA7yYNzeeNG/ikgTpEc4zU8G+6h9yETfJdfM9TpCTy2PdZUmGSdG1zE0+bnxdzDkmnBZjU5unDd0Bj6iHsn04G1bKSBWfHfYQZkUAKYPMJFlFKxh72RZe5fXTEUQO76xpIPDMh1TwsMbCVbv/57Cn4yOEPe/uOPp43buCTKsQhZopykhcbOZckbKGaDzgd8ZREnvI+UytMWl3bnMTT5ed1nUPShMikNh86NAULC2vovxsLbY97hByRQHpCEaVk7GFfdJmbG5RsQYYa2DHXQOqZ8b0Xl0IMbKXbxY0lY+lWmumnoD5vGDJBCXxZckUN1NnvI92Z7LquFLKDIeciFVGQSGH2HGuMrsE2/GHfZ+okCq2ubWriifXz2s4hrYQoxPYeqce9qIrbbkYkkB5Q1NBSzGFfhoGq1KCEDTLYwI69BlTPjAbh6iS9HcOSbaAQA1vpdmbf1I7SrWamT3neKGQCE/hs5AoTqG3fh+Pxo1xXLNnBkHOpiph+ZuvUK9BeXHQmUpQ9xyG351DfZwwx7Xa21Lu269U6TFcnYOv8CvQs31Gr8UaaEIWAxKtZdMVtNyMSSA8ocmipK/CUZaAqRd3DBhmseZ96DVyeGQ3ClWxvw/NnFo3r2qojI8afoRADW+n2g3N37SBQmt3slGtNJROuwOciVy6F2PV9qKoL5bpiyA6WnEtHmKTfZeqLn4d3Xj/rJF7YPcdFbc/Je585CeDahbZq1zaF7GjN/gzR9CSFxKtZdMVtNyMSSA+gZvxY/w/mgOsPPPurW3AhMweyLANVsWoAJ8i4Aru2x0yDcD1/ZhG+N/+umrDc2bryvx+7cdb4M1RikFe6/Y27PwFL5zcu/Z3MTD/v2cRea859tgU+qdKuvd6Re11tyQuFnGuMMKkimg8oe47Lsj1HkgBO7m+odm1TyI72xAftMrTmDm6uV7MMFbfdjEggPQAb2LElO84BV2k0YHx2BtYzZmYfA1Ul3hKXuucjyGh6zDTGB3WSHry2sm78b6+trMOjc9O55WwKMcjzWPU/a9RM3/VsYq+15D6bAp9Uadde7+hjNzYlEQo1woSy5zjE9hwMJAlgrT6qNheYQ3Y4jTe+vYBJL4GnTz+juoOb69UsS8VttyISSE/ABHZsyU6zpIj9bhiE8Jb4CjJaHjMNYrDW3YKVzpbxv610tmCtu7VjB3A/OMTAVrqlZvqYZxNzran32TUyRaq0U9c7uhpGfIz/4SSDvkeYUPYcSxU0il84DxoJoNZcYA7ZoTTeSM5rSnn/v7zyX734WjlezbJU3HYrIoH0BFdgx5bspAecKdvUUiNCeEt8DebW8phpEIPJ2ig066OwbCCRzfooTNbcr6kWMaBk+thnE3Ot8YOPcSNTpEo7dr0jtmHE1/ifsm3XoO455ihoHL9w7u9SSACpXdt5kJAdzMQHznlNrX51kg784Owp4++S+lo5Xs24wtAvIoH0jLzAji3ZcQ+47SSBN776JCy88GJutikhHSG9JT4Hc2t4zKTEoF6twO3NiR0eyBS3Nyes6oqPchQ206c+m67nDXOfKSNTpOQK832wDSMAfrpdy7hdg7LnmDMzleMXzoOmMowdJ5QHn2SHe15Tq1+r7TVY3DCfmRjrB0bppHo1y5Zk7SZEAlkQsCU77gEnVQddJbmQ3pIQg7lNfy9WEdAgBsdumAEAMKoqJvi0D2Azfe2yrOs+d7sJaWSKlFy5vg+lYQTAb7drmbZrcPYcY2emSvzCJoQYDE+BL7LDOa851a8DjUmY2TcFCxuDZ6bNcuRzSHgZk6zdgkggCwK2ZMc54CTqILYkV4S3BBtkMAOMU1j/XqQioEEMqiMj8NiNs/Do3DTK1xXCPuDK9H0F37z7vLHeYY1MkZKrvO9DaRjZ8X0CDF0uA3zsOZb4hfNQpjmIvsgO57zmVL/q1Tp8aO4u+PvT/zjwMzbLkbbP34QyJVm7BZFAFghsaZZ6wEnUQWxJTqPcorXpJAVlgHEK199LUQRcxAAz1qJerTgDYJlGU4QMvvsm6qojU6SgNIwUCa7NQXMMixY0/MJZFDEH0ZXkapMdznnNrTD8xt2fgI2NLtpypNHIFFEMIoFkQuNwxZZmqQccVx2kluS45RZf5QqKHw0A//dKFQGNdW39KNNoCo3gi1WMa7Wq2sgUKkzJDrVhJDS4Noe85/W3p4v3jEn8winynrcQyjAnyeXANKWAel5zKwxUy5GPEVcRYRAJJBHaZAAAX5rFHnBcdZBakuOWW3yUK6jkF4D290oUAe11baHtAxgFixN8OcFUa2QKFq5kh9IwEhpcm0Pe87rvlRp8dO6Yvy+MBNUvnEKbvPXabWiduwi9zLIGG6hJLvk72aYUMM5rSYUhG9fyRm/5GHEVEQaRQBIRcnerBLMnPg3jY3VYeOH7aHWQW5KjkCtf5QqOHy1ECdLHurZQoyl8z/nkBFPMyBRsyRYzR9CV7GAaRiieXBsopWiuzcH2vP7z2VPwkcMfJj+vrpmdJtj+VqpfOIUWeeO+F5wkNwXW7oOZUkA5rzUqDK7RW2VrZIrAIxJIAora3crBSLUK7/nCSbjq2OPooBOiJOerXMEhgyH+XukmnTyrRIjRFD4bdSTBFMA8MgUb2LFzBCnJjqlhREvx4hAWrs3B9rwubiyRNvBgZ3Zy/1aMXziF9HnrB/e94CS5FLsPdUpBP1zJiaS8jyG1ZWpkisAjEkgCyrK7lQJq6dV3SU6jXGFSdLhkUPPvNX0v7iYdl1UCax/gNlD4btThBFOXCoMN7Ng5gtJkR0vx4hAWrs3B9rzO7JsibX6izOxM4Stp4XbMZyF5LzhJLsXuw5lSoFVl6H83+4EltUU0MkXIEQkkAWXZ3doP7U5mTElOtPtaUK5wKTocMsiZWUf5XtxNOlirRF6CIA0Mvht1KMEUo8JgAztljqAk2dFSvLiEhWtzsD2vH5y7C11h4ahhPpMWLbuK5L2gJrlUuw9nSoGUsJvezc7yndCYeghGRipkUrtXRlztFkQCSYCvtXoc+By8CmAuyXFJSZZwcssVLkVHQgYlM+tc34u6SUfDKiENDJJGHcyEAkowxagw2MBOmSMoSXa0FC8JYeHaHPKe19+4+xOwdH7D+Z0BeGqYz6RFy64ibWCjJLlUBZw6pUCDsJvezfkz34WJVgem5n6tdKO3InQRCSQRPtfqURBi8GoWVFJiI5zUcgVF0fExwFj6vShjLaRWCY3AwFGwqBMKMMEUq8JgAzt1jiA32dFSvCSEhTslIW8MC2XKBIc4+J4uoGFXkTawUZJcjgJOmVIgJeyYd7NWqxU2eivCPyKBJCLEWj0Xihi8yiElLsJJKVdoKTraoHwv7LgmqVVCS8mhKljUCQWYYIpVYbCBnTpHkOvN0lK8NDruuSOosM+rCZyZnb6nC2jYVQB0GtgwSS5HAcdMKUghJezYdzP06K2IcIgEkgnJ4SpFEYNXqaRE289U1q0fPr6X1CqhpeRQFCxJ2d0WTCkqDDawc+YIcrxZWg1aITruOXB5oTnEIcTfKq1Q9L8X+6tbcIEwB5IKrgJumlKQhVhNRb6bFFIbMVyIBHIIwTX3S7bnUEmJtp+prFs/fH0viVVCW8nBKFi+JhRQVBgs4eXOEaRCS/HytR+ZC6wXOo849Npt6OT8HWX7W22oNBowPjsD6wtrot9jO5d9dydLCDtVIcWQ2ojhQiSQnsEZousC9cXV2J5DJSU+/Exl3frh43tJrRKhVSufEwqoKgy2ZEuZI4hB3sBwLU+u9n5kLqhe6JQ4bCcJzH/9KVQTHvZv1Z5CERKUc9lXd7KUsJvezenDd0Bj6iH17xpRPkQC6QmcIboUUIKq1vYcCinx4WfSUnRs4GwNsX0vaYDjWiVCKzk+JxSUfUZcqP3GGPgmVBJriuaMR99TKLDoJR3otpdY17tMW824yYnp3Tx0aAoWhKpsxHAgEkhP4AzRpQAbVDW351BJiS8VzEeXtQYJ6P9eRQQ4k9odUrXSmlCQR4LKOiPOx35j6qxVyfNGIZ1ca4q2J7qIKRT9SK/3O6/9BDqby+T3e1i2mmEraGV9NyP8IhJID5CslKLC9eL68KZhSckw+Zm0SUDIAOdb7cZCWnYvi6qUhS2Iaq7IA+DPWuU8b5zrzbWmaHqii5hCkYX0/S77VjPOmZJWbyYPRJ/jXkEkkB7AGaLrC1RvGqeE60JZvFt50CYBoQOcD7Vb8hxwy+5Fq0pZYIKo9ngpTpmX+7xxrjfXmqLpiS5iCkU/NN5v31vNpOc45UzJVm9mD47DXbdMF2LhiAiLSCA9oIjp+3kqCdabViYfV2hwSUDeNQ8Z4LTV7qKegzKoSllggqjmGCdumZfzvEmut82akkdcND3RnCkUms2M1OvdSXoD3f6+PMMa7y/1TMlWb+aXW2ILR8RwIBJID+AM0eXCppKkwHjTfPi4hgVUEuBSpiQ7lKnQVru1ngOqh88X6eYSh25nCxVENcc4ccu8nOdNcr1N1pTtWg3+PwdxoXqi854hyhQKH/YO7PVOtrfh+TOLxnmj1ZERL1vNNN5fypmiXb2JGC5EAukJoabv21SSf/+ZXwQAtzdNvYRLJA9Fg0oCXMqUZIdyPzDNDZpqt8ZzwPXwaZNuKXFYu9BGB1GtMU7cMi/nedO43v3WlL/61mknccF6ojHPEHYKhQ97B/Z6P39mccfGo+XO1pX//diNs+pbzbTOccqZUtYNYRFhEAmkJ3Cm71NHcLhKDd3Mvt88b5rWIcAlDy6EIKRYEoAt73A3SADQmhs01W6N54A7qkWLdKeQEofJ/Q10ENUaLyUp85JnZSpebypxcXmiMc8QZgqFz2bG9Lp21n4Cnc2VgevdSXrw2sq68WdfW1mHR+emd5SzNRpmtM5xyplS1g1hEWEQCaRnYKbvc7tPXaWGtZz/loXWIaA55w2AR0i5ZBNLArDlHcnsQmpzg5baLX0OpKNaJKS7HxrEoVYfJRNzjfFS3NFXnOdN63prqlDUZ8g2hcJnM2N6vaenPgbvnDs3cL3XuluwkkngU6x0tmCtu6U6xB5Al8xhz5SybgiLCINIIEsAbvepq9Qwub8BK6st5+drHALac94AaIRUS/10kQBqyZg6H43T3KC1a1b6HEhHtVBJUF7DhhZxkBJzTjIjHX1Fed60BrRrEhfNcT8hmhkr1TrUDNd7sjYKzfooLBtIZLM+CpM1/dCrSeYoZ0q2ejPTfLcLO2J3IxLIgiHphnSWGur42yv1cWnvvqYSUm31Mw++G6QkzQ3YXbO2ER+S50BrVIuLBLk6TbWIA5eYayQzIUdfSYdAaxIXzXE/IZsZs6hXK3B7c2KHBzLF7c0JL7vXAfTXqmLOlGz15pabpmENIVxEDD8igSwY0u5TrfKl1MelvfuaQki11E+sB9VngxS1uYHim80jXl/+1D3vfobgOfCxvtIEV6epNnHAEvMUoZKZMkGLuGg/Q6GaGU04dsMMAICxC9sXQqx7zUNavRmrj0JcZLg3EAlkwZB2Q2qVL1NwfVzaBz+FkErVT6oHVXLNXYQP29zA8c3mEa9943X4+AM37fi3jVoVmvtHYbW9Agcq+O5QX+srU2AbNooiDj6sHP3oJB2Vjl0t9JfpqcQlb8SS5jPkeld9LE5IUR0ZgcdunIVH56YH5kD6ho91rxERWUQCWTAo3ZC24EFVSXxA9eAnEFKp+sn1oFKuOYXwYZobqN/ZRrxefPUcHDt6/ZUAmvQS+Mbrz8GphR/BcnsFDjaacNfspfl01Yo9yGqurzQRDGzDhos4+Ors17ZypJDcEx+wleldxMU1YsnHCtTsuxpyYH69WlFvmImIKAMigSwBXIShbMEjD3kHfyfpwOrGClk1wRJSifoZagMKhfC5mhs439lGvBZXWjs6Zb/x+nM7NmQstZev/O8Ttz2O+nslHj4bwaA2bGSJg69RUym0rRwpNO5JP6gjw7KQlOmxI5Z8+kDLvDhhWOboDsv3jPCHSCBLABdh0A4e/fBxCKQHf9JL4OnTz7CJL0WJ4KqfIdYOcklqXnMD5zvbiNdMc/wK8eokHTi18CPj7/7h4o/gY7f8mkrp1PbcuQiGpGHDtz/Rhw9U855wR4b1Q1Km9zmbEQuf21MkxNx3cqOFYfmeEf4RCWSJYCIMvgI65xCg+oW0iC9GieCWvUKsHdQmqZzvbOuUve+Ow1fu52p7DZbbg52jAABLmyuw2l4TDT12PXcYgsFt2PDtT0yh7QPVvCdcu0Y/JGV6rRFLEu+ij+0pGsR8WJqvhuV7RvhHJJAlh6+ATjkEOH6hUEpWFtSyl/YGFBO0SSr3O+cRr5PHj8DS0kUAADjQmISDjSYstZcHfn5qrAkHGjJC7XrusASD02nqy5+YhcTDZ1Jmte6Jll1DUqaXjljS8C762J4iJeahkhspMN8TQJ50S+GzOSriXUQCWXL4COjUw4rjF/KtZGlCYyOHrXQlIal5pV7Od84b8VHt6wytV+tw1+yRHcpxijtnjohIP+a5oxAMaqepL39iHijJjE2Z1bonWkq4pEwvHbGk4V3U3p6iQcxDJTdSYL4nzPkbU+RCyOaoiEggSw8fAZ1yWHH9QhziW9SIEslGDmzpikr4XKVeyXd2Ea8n3vtRALikFC9trsDUWBPunDly5f/nAvvc+Rr+HGpOJQcuZVbjnmgq4ZIyPXfEkqZ3UXPgtgYxD53ccEH9nqHP9DI3R+1GRAI5BNAO6JRDgOsXohDfsnSZczZyYEtXVMKHtRhIt4iYUK1U4cRtj8PHbvk11cMf+9z5nOGo5U/UbD7DKLPVRkN8TzTtGpIyvW3EUt5sSABd76LmwG0NYh4qubFdXwyw37OIM91nc1SEGZFADgEwAZ0S0CiHlcQvhCW+PrvMOcBmzdTSFbZDk+uHko5myaJeravaDLDPnfZw/H5IZwz66EClVASk94RjfUjPlmT/4LsgGbXTP2LJNRsSwI93kWqDMJ2zWsTc5xB+zPXFAvM9izjTfTRHRdgRCWSJkSUEpuBhC2g2YA8rrl+o1+tCr7sGn3jvMSvxLarZxgRq1owtXVE7NKl+KI0OUA44hNX13PUH6Fqj4W04Ppf4+OhADVm+pCjh2bPl3OwMjN/1AS/jWjCzIbW9ixTknbMzX/oCAOj4qH0MUE+Bnb2p8T3bW8Wc6T4SjAg7IoEsISiEwBrQ/o/fyf0MymFF8QvlffeZHDJTpmYbataMLV1ROzSphEJjNAsFEsKa99xtJwnMf/2pUs+W89UpW4Q3E2N9yJ4t7fkFaDvIMqe0T5kNqeldpCDvnH1zrA6THz8h8iRnoT1A3dfszbzvuby5WsiZXmSCsVcRCWQJgSUEroCWtM1yfj8whxXFL0QlM5Iuc81RDRwlFFO64nRoUgiFtAO0125D69xF6CWj6ICvQVizz52Wsict46f2hf1bg9fCZ6cspXypbVUwgUqWJaV9ymxITe8iFrZrsfTSD+CqY4/vKGdre5Kl0Jq92Q9bonBw7IDXUWA2FJVg7FVEAlkyUAiBK6B1lpYBRq9S+24uvxCHzHC6zH2MauAqoc41lMwOTSyh4P5+bsD34fvUUPakZfysfWFm3xQcmbp9h33BZ6kZUxEIaVWgkmVJAsCZDdl/FvleqWe7Fu3FxdKM2MmDdPZmPzDnRmPU3ygwF4pIMPYyIoEsGSiEwBXQ6lMHAS50vH7fnd+PR2aoXeY+RjVwlVBX6YrboYm1GHB/Pzfg+/B9aih7UlU0a19Y2DgP/31jp31BUmrGdr/aKgIhrQoUsixNALizIUOt1LNdi8bMTGlG7ORBOnuzH9hzw9coMCyozVERPEQCWTJQCIEroFUbDQAIRyC5ZIYyNkZrVENWtZDO28wrXUk7NF0WA87vlwR8H75PqbInLeNT7AvUTlmt7letLTJYUMiyRgLAGd0UaqWe7VpMHf0QWfX0rZiaoDEai3Ju+BoFFlEuRAJZMlAJATWgSeeAaX73LDAjSqSjGmzNGr6yZo0OTc3fLwn4Pnyf0iYS6SBnin2B2imr1f2qvU8dg+zZ0piZgfG77h44WzRK+9TRTaFX/+Wdszef/CwsLm2gfkcoxdQEjdFYnHNDexRYRLkQCWQJQSEE2ICmOQdM67tzIB3V8OaTf2lVLXxkzZodmhq/Xxrwffg+JTPwKMq31q5pTPOZZver9j51DLJnyzXvnYMlgyVGs4u8fzakDaFX/+WdsxTiF0oxtQF7fU0Ylm05EeEQCWQJwSEcroCmOQfMBt9kSTKqodduw9JLg8oZwE7VwlfWjO3QxAwyN/0b7O+XBnwf40SotwAAIABJREFUvk9sImTqvMeooiF2TWeh2f3KsioodWunZ4vNEqM1BBs7xL8oMsMdsaOlmBa17hWg3KtAI4pBJJAlhtZICK4S0kl6sNbdgsnaKNSrdpUyG9h9jrPgjmrYWl2F9oL5OkhVC42RQphB5lorwjQCvg/fZ16AdnXeu1RR6q7p2X1T8P7LXdhcaHa/AuDV/SIGy0uHYFOfa00yE2IsklQxLcu6V5/bciKGD5FA7gFQlZBkexueP7MIr62sw0pnC5r1Ubi9OQHHbpiB6sjIjp/3MVLHBe6ohtEDB6AxOwPt+cEmHK5qofn3YwaZa60I6w/4+6tbcCEzB1IaVLWtDK7Oe5sqytk1fct118KFZfccVRs0u18B8Op+6MHy/eAqdJznWkpmQhJtqWJalnWvPrflRAwfIoHcA6AqIc+fWYTvzb/bVLDc2bryvx+7cXbHv/UxUgcL6qiGSqMBU0ePwrlnnxv4b9wSjNbfj+kEBgD1FWGVRgPGZ2dgfWENAPSCKsXK4FJvKZ33JlWUs2u6MVoHABmBBNDpfs3Cpu6H7tbWAHedqZTMcIl2//OKhUQxLdO61xTa23IihhORQO4CuAIwRQnpJD14bWXd+DmvrazDo3PTV8rZWiN1QuLmk5+F1mZHpQSj+fdjOoEBwPuKMG31ykZ2sOqttPO+SPO/RvcrBUV0a0shXWeaJTOYMTkcom16Xh+4+zo4fv8NqGoDVzEt07rXiIh+RAI5xKCUT7FKyFp3C1Y6W8bPW+lswVp3C6YvZ7vSwF4ENEswmn8/thPY54qw0OoVVr2Vdt77Nv9jyv2S7lcKiujWlkKyzrQflDE5HKJtel6f+c4bsNHqoKoN3LNH6/qUFZoraSPCIhLIIQalfIpVQiZro9Csj8KygUQ266MwWXv3kZEGdht8HyoaJRjNvx/bCazVLdw/DzRFSPWKot5KOu9T+DD/+/bQcWa2SmexFgGtLnjKmBwq0dasNtjOHlMy4mtKQBY+ZwSbUIR/PkIX3gjkn//5n8Nf//Vfw9TUpYDze7/3e/Dggw/6+rg9B8yBZoJLCalXK3B7c2KHBzLF7c2JHd3YGoE9i2E6VCh/P6ashhlkLh12bpoH+v67r4V77r8+qHpFVW+5nfcpfJj/fTWrUGe2ZpMt37NYKdMZsBA/18QxOVSi7bva4kpGfK4GDDUjOIsi/fMROvCqQH7uc5+D3/zN3/T5EXsWmANtjvm7j90wAwBg7MLOQhrYsyjqUOGuF3P9/ZSyGmb9l3RFmGke6EvfeRNarQ78yiO3ooOqVCGmqrcj3S588q4m/Pv75mCtC+zP5fjlTPBZ7sfObLUlWz5msSa9bXj27QXUdAYA2rWVPtecMTkUou2z2gLgTkZ8rgYMNSO4H8Pon48YRCxhDyk0DrS8obTVkRF47MZZeHRu2qk0cEfqmFDEoSJdL+b6+znbJzCDzDnDzjHzQJ1bZpQUYqx6m3d/6sK5c9L77qvcT5nZ6kq2tGexPv3js6jpDJJryx3iz2mUokwK8FFtSUFJRrSXHGhuS6JgGP3zEYPwSiCfeuop+Ju/+Ru444474Pd///fhQFx1pAbJgYYdSluvVq40zGC+j/SF5xwq0s0MWuvFTH9/6H29LmDngdqCqqZCjFGvfa1/k/5eX+V+7D0KnWx1kh68/HNzJ3B2OoPWPaOUyiWNUliibXpeH7j7Wjh+/w3On7WhyM55zW1JFPhWdCPCQEQgP/e5z8Hi4mD28ru/+7vwmc98Br70pS/ByMgI/Nmf/Rn88R//MfzRH/2R9fcdPLgPRkd5h97s7HB3onHw5U/dA/vG6/Diq+dgcaUFM81xuO+Ow3Dy+BGoXj5wTdfla//zr41Dafftq8Hn7vlUsO+fxeSBcZg9OA7zy62B/zbTHIdbbpqGsfqlRzbpJfBfXvmv8IOzp2BxYwlm9k3Bh+bugt+4+xPOzQzpNUnabXj71MvGf9M69QpMffHzl9e32ZG029BZWob61MEd/7517qK1rLa/ugXjs4O2AF9oHhiHAwfHYdVwfQ80x+HGm6agVu8/EnYGrc3OFpz66aDCAwBw6qfn4bc/MX7l/mDxHz/zS7DZ2YLlC204uL+x4+e17k8WmN8L4D5TOst3wvyZwcaG6cN3wKFDvICPvUfnFi/C0lp+slWt12B25irWdzBh/mIbllpd439b7WxBbXIMZq9qqNyzpLcNT//4LLz88xVYanVharwGHzjUhBPvm4NqZbBUnmLmS1+AN8fqsPTSD6C9uAiNmRmYOvohuPnkZ0k7q22wPa9Z9JIOdNsXoNbYDxVLcttLGnD+jYPQ2Rzssq6PNeGaw4cHfh77HVygnwk4YOLxA3dfB8985w3D/38tzF3bJH9m2bEbOYqIQH7ta19D/bsTJ07A7/zO7zj/3fLyBut7zM5OwsLlQch7DR9/4CY4dvT6HeXTpaWLAGC+Lp2kAy++bT7gv3/mZfjI4Q+rD6WleKHuumXaqKredcs0rK22IP1rnj79zA4SvLBxHv7+9D/CxkbXupmh/5p05udzVxu2FxfhndfPWju1XaW6XjJqLatdSEavDPAOhRtumTLOA73+lilYWR0MIv2YX96ABUOgAQBYXGnBT986z1ahRwF23F8A+f3JA+b3XnfkFueZ0ph6CCZanYFyf2PqIdF5hLlHSTeBqcl8BSfpdJ3fgbJtqJv0YGq8BucNJPJAfRS6a5uwsNFRuWfPvr2wo1R+vtWFb7+1AK2N7sAigywmP34Crjr2+I7zZnGJF1dsSJ/XMcMZy+nOr0/eCp3NQe9xffJWOL/UhnSovY8mQ8mZYAI2Hh+//wbYaHUGKhDH779h18XzYeYoNuLrrYQ9Pz8PV18+KL71rW/Brbf6MeNG0MrHmkNpXY0UHC8UpqyptZlBOmDaVarzMX+Q2/SRwjQP9PbLXdguhC47+RoArvV7KR46CjAzWyUWFhbBqVbgA4ea8O23Bsvm/dMZpNeWssggD0VvSeF052Mbenw0GfrYloSBpn8+ohh4I5B/8id/Aj/+8Y8BAOC6666Dr3zlK74+KoIAjaG02CyY44XCHCpaJFhC8LD+Rq35g9KmjxSmeaDXXttEZcdajQRY5cvXAHDt36vdrIKd2cqdgMAdP3TifXPQ2uhapzNQrq0pGaIsMigjuN35mGTEl+819LakLDT88xHFwCuBjCgfNIbSYrJgaQOJ7VDR3MzAJXjYsSFa8we1m0m4m1EkY5s4ypePAeA+f68mXPeIo+BIxg9VK7jpDK5ra0uGKIsMyghpQ4wtGfHduRxqW1LE7kG538YIL5AMpcVmwZy5bFhobmbgEjxqqU5SVuOQcWmpOw+SshNH+fIxANzn7y0CFAVHo+PXNZ3BdW1dyRB2kYEvSAal+xzGHzuXI8qGSCD3ICRDabFZsC//WgrtzQwugpctu/rer9wPChnXKnW7kCUtLsIqHbyNIeCc4eZF+eWk46e4kBIcSmJiuraYZIiyyIAKm30i2d6G588sogelm+BzlaTPWZQRERxEArmHwRlKi82CfRMsn5sZ+mEru2LKoBr7ZSlk3NfcxDxgCavPWXc+OlPbWx1Y2DjvfK6opBU7g9UXuARnO0ngja8+CQsvvChKTLDJEHaRARYY+8TzZxZRg9Jd8LlKUnvzV0SEBJFARpBAyYJD+My0NzNk4Sq75pXqNPfLYsl4EYPLsYTVZ2lPszM1JXg/WnoNFjeWcgkel7R+4/XnjDNYAcA6fkoTHIKjlZhQkiHKIgMXXO+xRvd3Cl/d+QCxczmiXIgEcg+CMv/NBGwWPOw+M2zZ1VSq094viyHjPn2nJlAIq6/SnnZnKpbgcUir1vgpKagERzMxCWn9SIF5j9e62yrd34NWF5yqTj2TY+dyRBkQCeQQAOs7cpVLOV2wJlCz4BA+M4nxPQ/csitnv6wrgGDIuMR3ykkqqITVR2lPszMVS/C4pFVzBqsG+gmO7f5rJyahO+Ax7/FkrSnq/uaerVpnckREEYgEssTA+svyyqUf+9QHdvw+7vw3ADOJ5WTBUvUzCw3jex64ZVfKfllqALGRcY66s73dg5/9+G/h/LkfkgMYlbD6KO1pdqZiCR6XtGqOn8LC1ayDef40GuKy50fIygTmPa5UKqLub+7ZKjmTXSiqUSti7yASyBID6zvKK5eOj9fhlx64EQD4XbBaXb2+Mm0t47sJ3LLrvok6TOxvGEnkxGQD9k28e5hrBxCquiP5fG45UnPwtmZnKpbgcUmr5vgpF7DNOpj7Lyk7286PbDIkHT2Vl5xi32Nu9zf3bJVOJshD0Y1aEXsHkUCWFFjfka1cevrVd+Cuo3NQq1XZ5Vgt87yPTFvT+J4HTtm1VqvCzbfNGPfL3nTbzJXytY8AQvGdanx+GQZya3WmYgmehLS6xk9pKfQYLyfl/s+e+DSMj9Vh4YXvk+4z5vyQJqmY5BTzHldH7IPS8zruuWerr8kEZWjUitgbiASypMD6jmzl0tWV1pVyKaccq2We95Vph1h7Ziu72hQTzH5Zn6NtML5Tjc8P1Shl8/dqdqamRO5fll6DhY2l3PmiXNKaN35qe7sHS2e/qaLQY72clPs/Uq3Ce75wEq469jj6PmPPD2mSiklOKfaJbPe3reMegG918TGZQKtRy9cigojdhUgglaD9wmF9R7Zy6YHm+JVyKaccq2We90WUpGvPSEOR+8quGMUEs19WI4BIFCvNAOarUYoyDkmjMzUlePsPnoCf/uu/5frHpKQ1O35KU6HHejk5959ynzHnx+iBA6IklZqccuwTto77//iZX2JbXXxMJpA2aoVaRBCxOxAJpBC+Xjis78hWLr3tjmt2kBZqOVZrm4yvGYD1Ks/4Lr1nFMXEtl9WEkA0PKXSABZCpdAeh4RFYxQ3X9REWqnNC9oKPdbL6XNrCgDu/JAmqT5VfAD3mKjNy8krd8IA9+fyEkdpo1boRQQRw41IIIXw+cJh/WV55dJHj78fzi9dvPLvqF2wWjPbfAYqjvFdcs+0h3VzA4iWYnXwukdh33gdzp97Ff35oVQKzjikIsFtXtAmQZRmHZ9bUzDnhzRJpSan1KTH1XG/fKENo8CfMED9OVfiKGnUKmIRQcRwIxJIAXy/cFh/WV65tJKjwFHKOFpNEr4Clcv4nkUivGfaM/E4gUdTsRoZqcD17/sY1A/+KvrztZOmvOYEyjgkTXSSHsxfbEM36ZGasLjNCz4UeuyueJ9bUwDc54c0ScUmp9ykx9Vxf3B/A9ZWWzu+D9QmIemuARCuJfZMxiSO2HufRehFBBHDj0ggBQj1wmF9R7ZyKRdaTRK+AxV27VlnaVl0z7TK+llQSL2Psh328zWTJtc6QMo4JI3uZclMUUnzgg+FnrorXnO0Uj8w54c0ScUkp9ykx9VxP1YfhbXL/9v3UHBs4ki99yl8nW0RuxeRQAqwl144rSaJNFB1uwmsrbZyt+b4Qn3qoOiecRSTPIWNC25HvYZfUTNpcq0DxIxD0gzakpmi0uYFthfOcV9tu+I1Payu32U7PzhJajZhsCWn0qQH23Hvcyj4pd9HSxxt996EItZMRgw3IoEUYK+9cBpEiNJV6wNVhXuGVUxcChsGpsBMUay0/YpaSRN2HaBrHJJW0JbOFJU2L5C9cIL7qvlMaP4uTJJqSxjyVFRp0oPpuPc1qmzH9/DUjNiPMsx1jRgeRAIpxG544VzqgQYRSiHtqtVQTaT3DKuYuBQ2G1yBGatYafsVtZIm7DpA2zgkzaAtnSmqtWUGW0qW3FfNZ0Lrd2Hfa07CIE16+rvq88ZE+e4GB/DfNQ8Qbq5rxO5AJJBCDPMLh1UPJESoH5KuWk2lQ+ue2RQTrMKWB1dgxihW0tJdXlDXSJqo6wBN/l5O0M7zSkpnigLwmxeycPk5JfdV08Oq8bso7zU3YeAmPZSuei110FXl8dk13w9fc10jdhcigVTCML5wGPVASoT6Iemq9TEuyec9wypsJlACs02x4pbuXEFdg4Br7LCmBG33+BPeTNEdn8lsXsB+xxSSkqymh1Xjd1Hea4nKx0l6KF31UnUQW+WhWh1sG5wiIqSIBHKPAktSJEQoC0pXLee75qFfSQOQ+4QwoCps/dAK8tzSHTaoSwm4dIc1JWhjSp/9M0VXO1twADFT1ARq8wLlOwLISrKajX/S30V9ryUqHzXp4XTVS9RBapXHZXUo2msesTcQCeQeBZakSIhQFpiuWsl3zcKkpF28/z6YOP6E97VcEoVNK8hzSnchhwlr7LDGBG30+JO+maK1yTHorm2S5kBKQCnPSnyomo1/0t9Ffa8pCUOe/QKb9HC66rmjyjSrPCmK2uAUsbcQCeQeBZakaJQa++HqqpV81yxMStq5Z5+D5mYnyFoursKmGeSppTvt2aaY+YySHdaYoE0ff1KB2asasLDRYX0nDqjfUeJD1Wz8k/wuznvtShi0vNKSrnrqTE3NKg/A8G1wihheRAK5R0EhKdJS447PtXTVanzXFGVYyyVR2LSCPLV0p6V++h6qnIUtaIcYfyIF9TtKfKgaHtb+xID7uzjvtSth0PJKa3XVY6BZ5QEoboNTxN5DJJB7GFiSolFqzIK6NadoJU0CjsKm3d2PLd1Rgrpt9Irvocp5MCmeIcaf5AE7O5X7HSU+VM7P2hIDzvfgJkqmhEE7adTqqndBu8rD9ZpHRFARCeQeBpWkSEqNUhSlpNmgsT7PhTTIt7sJrC5vkMg7ZrZeJ+nAO+sLkCSVK6qKK6i7yoQhhipn4VI8NcefYO47Z3ZqqBEtEmgnBpqJknbSyO2q58yq1azycL3mERFURAIZoTbOJiShwvw7X1uCQpZnOUQE4wOzzrhzBHVXmTDEUOUsXMRGYxc75b5zZqf63hcvRS/peEsMNM4gX0kjtqte4r/UrvJwvOYREVREAhkhRmi/GxYmJW32/nth4vgTot8bsjzLISIYHxhmxp0pqGPKhKE9h6QOZmKDQz+w913aVSv5jib0b1KRePe67QvBEwMKfCaNGCuChv9Sq8rD8ZpHRFARCWSEGEX53VwwlccOzc3AwsIa+3dyyrNcZZZDRDAEb2t0hDzjLgW2TEj180lWVIZQPCn3XburlgvKJhUMao39pW9G0l4ti60AlKFpzwSq1zwigoJIICNEKMLvRoXmxhkKWZEqsxwigiF4qxNV8oy7FNgyIdbPpzF2JYTiSbnvWl212AacPFA2qWBQqdbxcxgV7Cwc5dTlqaT+TmwFoExNexERoRAJZIQIGupPCO+kFihkRarMcogIhuAdGB3hz7hDlgmxfj6Nsl+ILmvKfZd21XJ8r1lwNqlg4JzDqGBn0VBOs0kj53diKgApQjTtRUSUDZFARoggUX+K9E5y1R0sWdFQZjlEBEPw6gCiGXeUMqHNz6dZ9vPdwUwlqZKuWo7vNQvOJhUMXImBhp1FWznl/k5MBWDu8v/26b+MiCgrIoGMEEGi/hThnUySHvzVt06L1B0MWeEosyZS6yIipp/BELz+GXfLmytw0DDjLs+XqDV6RbPsF6KDmUJSuV21WmvtJJtUMDDOYVRImnwop9zfSa0ASPyX1NK6xDMcEaGFSCAjxOCoP0V5J5/8ux+J1R0MWaEos66SpYmIJD0LEUYQvP4Zd9WJHiTr786BxPoSpd5SH2U/Tgcz1kLBIanUrlqtBpyQm1RSaNhZfCin3N9JrQBwEitqaV1rVWNEhAYigYwQgxNYi5gV2O4m8OKr54z/jaLupLCRFYoyiylZZokI5mcwBK9ercPsxCQstN7tTNdaB9cPk8JSdNnPZqGwAUNSuQqR5lq7UJtUUmg0M/lQTiW/k2NFoCRW1NK6j3czIoKLSCAjWDAFSIr6U8R+4tX1NiystIz/zcd4FYwyyylZapU5TdAeR+JSWLTHrlBgs1BcffUJ1u+UKkSaa+0wm1S4DWy+VkZSlFOsj1mixvpY45qCWlrnvptac0AjIrKIBDKCBK0Sio/OWVcwPDDRgNnmOMwvD5JIqrqDAUaZ5ZQsfc4Z1B5H4lJYXGU/X14vp4Ui6bB+r4ZCpLnWDsC8SYXbwBZiZaRLOeV0qUvU2F67DSOrqzBz4ABUFIdxU0vr1HdTew5oREQWkUBGkKBZQtHqnMUGw0atCvfdcRie+c4bA7+Dqu5QYFNmOSVLzTJnFpq+RIrCki37+fZ6uSwU3fYFAKBdRy31lqt6UZQmbgNbiJWRLuWU06XO2Wvt+xmkltap76aPbvaIiH4Ut2cuYujgCpC9tlkVy0MabA6//z/A4ff/73D4/f/hShCiIA1qKSFIg9ryv/63gX978vgReOSDczC9fwwqIwDT+8fgkQ/OsdUdKdKSpQl5pJbzM1ikvkQTqL5EjMKShzRR2Tp/HmB7+0qisvD019Gfb0NqoTD/twNQa+wn/06MQkRB6nt1z41M4OnTz8B/fvFP4f9+8f+B//zin8LTp5+BpJcY/71Tfe11zT/n2oXd93OVSg1qjSlRI1yqnGbL1jb7Rrs7+Df32m3ozM9Dr902/s48+H4G09K6CabSOuXddCVvHabCHhHRj6hARqAhLW/mKSQu76StNE3t5q5W/XmauOCULLXLnP3A+hJdHjRu80KItXBOC0W1DgC0hKioYdJUpYnbwFaGXdgU+4ZEQQy1mpBaWse+m77mgEZE9CMSyAg0uAGS68XBlKa5wZA6XsUnOCVLqbm/31sIsJPIuXyJWA8at3kh1Fo47eHjlK5yre1LnBmH3Aa20Luwu90ENtY7sG+iDrXLzzbFviGx24R6BqmldeyoIN9zQCMiACKB3NMwHdA2cMeucL04GJ8WNxiWcX0ih9RSf8akyly8/z6YOP7EgCqTN46E4kHjNC9oKnm2Jhwfw8ddCpH29iWO0sRtYKPswpag1+vB9/7hp/Dm6UVYv9CGif0NuPm2Gfjlh29Bd6lLFcTQarKp0ckG16igIuaARuw9RAK5B2E7oCuObSzUsSvcLRDY0jQ1GG73Elg6+02VAM5dh1gkTKrMuWefg+ZmB9UERR0hxGle0JgPSSlfcoaP58GlEGlvX+IqTVz11ffKSACA7/3DT+GH//yvV/73+oX2lf/9K4/cirJvSBVEyTNYluQ09BzQiL2HSCD3IFwHtA3UbQtcLw6lNE0JamdPPysO4JwxIi6ECDoavi7uCCGqwiKdDxli4LLtnpkUIh/bl7hKE1d99b0ysttN4M3Ti8b/9tbpRbj3wfdArVZ12jc0FETqM6itLkvBSd4iIiiIBLIkCKVmYQ9oF7DbFrgKCaU0jQ1qvV4XVubNaiglgHPGiOQhZNDR8HX5HCHUD8m+bd8NENx75mv7kkRp4qqvmqptPzbWO7Cek6Csr7VhY70DBw6OA4DdvqGhYlOfQW11WQvU5C0iAotIIAuGDzXLBsoBrQGuQsLxabmCWtJdg86mWQ3FBnDtLTAhg46GKqO5KQUDzr5t3w0Q3HtGSYooA9R3k9K0b6IOE/sbxjNqYrIB+ybwf5fWliPMM+hDXY6IKDsigSwYmmoWBpoHNBZchUTbb1WtTUJ9rAmdzUE1FNtFqrkFJnTQ0do97XOEkAY4RBlrIZDcM0xSJBk9U4TSpL0pqFarws23zeyw2KS46bYZVHUkBUfF5laCfKnLERFlRiSQBcLnTuM8aB7QWHAVEm2/VaVSg+bVR2D+zKAaiu0i1SzhFhF0TKrM7P33wsTxJ9C/w+d+YA1QiHJeOXpm2nw9pPfMlRSF8G7mgUKefG5p+eWHbwGAS5aa9bU2TEw24KbLTX4cYBREaSWIOw0iImKYEQlkgfC509gG7QPahn5lh6uQmErTlLVt/Zi77THYaHXYqqZmCTdU0MmqRFlV5tDcDCws5G+FyQNlhJCvndZ5wJYv88rRZ0/XYWz64YHfK71ntqQo1PDqLDjkySfRrVQq8CuP3Ar3Pvge0pgxCaSVIO5opIiIYUYkkAUiVENCFiEOaF/NIdSh5FmiOVKpilVNrRKuNOi4SJlNJeJ4CznwvU84D5jypa0cvTL/I7j64K8OdlcrEQVTUhRqeHUWVPKkSXRtqmetVlX1Y9u+g0YlSGK54SbEERFFIhLIAhG6ISEL1wEtUY2ojQbYz8IOJc8jmr89fUmBknSRapZwOUEHS8qKLIeW5TvYiLKtHN3ZXMktR/uahRhqgHo/OORJg+iGbh60QasSxLHccLd0RUSUAZFAFowyNiRIVSNKowHlsyhDyfOI5r5XavDRuWOo6+BCrbcFze46jPaqAMA77DlBB0PKiiqH9qMM38EGWzm6PtbMLUf7moUYeoA6AI88aRBdn82D1A1b2pUgSnLK3dIVEVEGRAJZMMrYkCBVjSiNBpTPwg4ltxHNfz57Cj5y+MOiMpGPsiw26GBJmXY5lKNGF1WS/f/bu/fgKMt7D+DfvWQ3yibZ3LEE0SCZMhQQR7RVWmpIoDZAVaSV2jNirVa0pUBHR612RiyiTDtq6QzDFM9wZvSAxVs7ZBjlUm5VynGKE3TocKkM0UIum92QiOz1PX/QXZPsu/u+z3vfzffzl5vdsE9237i/PM/vola+4+hg3RTFoNCMXohWN1DXEjzpDXTNKh7UOmHLrpMgrVO6iJyCAaRDaJmDbAYjdo3UFhqIPpfapuT5As3eC305p9+oZeexrNqgzKjjUD3BspntdIyS6zi6oWk+ekMXTH/+kaxuoK41eNIT6JpVPKhnwpYRJ0Gi167WKV1ETsEAkoYxYtdIbaGB6HOpbUqeL9Csubwq5/QbNew+llUblBnV81FPsGxEOx2zx8DlOo522Zx/ZmUDdTXBUzyeRF/v54jHkygp8egKdM0oHtQ7YUvPSZDWa1frlC4ip2AAScMYtXOlptBAy3OpaUqeL9C8vmGarmMhu49lRYIyvcehRgTLetvpANaMgVN7HG3VyNFc8qUSaP3dzRc8DTsW/k/Lr6EFtknuAAAd/ElEQVTHwloCXTOOjI2asDXyJEhNPqXWa1frlC4ip2AAScMYtXOlptBA7XMN/dD0+P2qmpLnCjT/a/oi9Ok4mjSyUlaOmlxDtUGZnl0iwJhgWW87HaeMgbO7alhNKoHe3125NBo9x8L5iBwZqzkaNnrCltp8ylQypuva1TPHnMhuDCApi1EzZAHlnZ18z5XvQ1OpKXmu6Td6W2MYFWCPJJJrKBoYau35KBos5wt+tbbTEZ3IY1YOpdUjR0dSm0pg5O+u3mPhfNQcGYscDRs9YUtt4ByPntd17RbTHHMafRhAUha9O1dGPVf31ld1F6uYMR/YyA/pNC25hkODMjMmvagNlvVWpRsxkcfMHEo7Ro4OJZJKYOTvrlHHwvnkKx4UPRo2asKWSOBc4i83ZJqUHXPMifRiAEk5WTWtRO657C5WycfoAFvPz2r2pBc1wbLeqnQjpruYmUNp18jRNC2pBEb87hp5LCzam1FLWoNRE7ZEAme3x8cRhjRqMYAkVYwsHlBzzGh3sYoaQz+kRT8gh9Lzs2oN3obuWAK5d0mUgmWjAn09013MzqG0a+Romtl5t7kYcSystTejnrQGvSMQRQNnsyYTETkdA0jKy8jiAZFjRr0fmlb1E9T6ATmU1p9VS/Amt2P5+Te+jsCCO/LuWOba0TIq0Ncz3cXIHEo5do8cNSvvVg29x8Jai3CMSGtQkivtQzRwNmsyEZHTMYCkvIwsHhA5ZtT6oWl1P0EjqlS1/qxagje5Hcuz29sRvBjT1ATd6N0xLdNdrAg27B45akberRpDj4VLfSW4GIur3mHXU4RjRFpDLmrSPrQEzmZMJiJyMgaQlJORxQNajhm1fGha2U9QywdkrlQALT+rlippo/NK7dwdy6zBxGAjza6Ro7FkLFOda1Vhm5ySEg+qasagp2dA9ffoLcIx62hYTdqHUfmURMWMASTlZGTxgJZjRtFiFTVBas7v1VDFLPIBqZQKoKUwRzR403vcnCvP067dsaGsykPTO3JU7XWWTCXx5sl2dPR8jHA0gkp/ENNqL/UHNDr316x0D71FOGYcDYv+EaU3n5KomDGApJyMLB7Qc8yotqJUTZAKDA9S9VQxi3xAqk0FEK2eFQneNOdaKuR5Wtn2KRen56GJXmdvnmwfNqGkLxrO3F7ctNCYNZmc7mFUb0Yjj4YLoTiPqFCYP0KBCla6eECOmuKBeDyJ/vAXiMeTmWNGOYYdM/4nSJW/Tz5ITR9nJUIhQJIyx1k927YqPl/6A1LO0A9IpVSAaDyp+Fy5pIO3q1avwVW/eQ5XrV6Durvulg1K0juWcvIdN6fzPNOBcjrP8709p7L+fV9dnaXBYyyZQuhiDLFk6tIa3CUo8Vepvp5S0Shi3d1IReV3ko0icp3FkjF09Hws++8c7f0YsWTMkDWl0z3Sf3Sl0z3Cn71ryL8PXMolnHr9OJSV++FyAWXlfky9fpxiEY5Z70v6jyjZ+0ysaCcqRtyBpLy0FA/k2rH6xi0tAMSOGUXaB4nmwhmRE6gm2d6SPoIlbrgqvEBJ/r8J5XYsa79xIwIL7pB9vJnTSPRIShJ2nOnFscggIrEEgj4vJgcDuPXKGnhcLsXvN7t/5lCi11l/dADhaET28X0XI+iPDuhuOm3V+EjRXEKz3xcn5OwSFQsGkJSXluKB/JXJ6o4ZtbYPEsmFM+I4S80HpJl9BEWPIeWOm+sbanIWR2gphDBjKs5IO8704r3uL4OscCyRuT1/gvyu+VB6m5+LEL3OKvxlqPQH0RcNZz2+qjSICr/+qnKzWx+NpDaX0Ir3xQk5u0TFgAEkqaK2eEDdjpVyTpPW9kEiuXBGtqDJ9wFpZh9BrVXnanMtRfI8rdrViyVTOBYZlL3vWGQQcxuq4fPk/iNDzY5gvubqokSvM5/Hh2m1U4blQKZNrZmialby0Optucdb0fpIlFXTp5yQs0tUDJgDSYZSs2OlxIicQTW5cFpzAvMZmZOX9oPma9ByfQOqy0vhdgHV5aVoub5BVx9BxWPIVFzzv52mNs8T0JdPKmIgnkAklpC9LxJLYCAuf1+amh1BI2m5zu64pg3fbpiF6tJKuOBCdWklvt0wC3dc05b3uZKpJLYd/wueOfQ7PH1oHZ459DtsO/4XJFPDf2esyElOU5vPaMf7YnXOLlEx4Q4kGcqI+blWzh426jhLKSfPjD6CVh1DqsnztHJ2eVmJF0GfF2GZIDLo86KsJP//1uwYDSh6nXncHixuWojvTfxO3p3EkUSqt81ufSS6I23XyEYi0oYBJBnKiNYdenIGRXvaGXWcpTYnT28fwaGsOoZUk+cpmuenp/egz+PG5GBg2OudNjkYyHt8DdhTSKH1OvN5fKoLZpSqt7838TvDglDR1kcXYwl0hy+o/uNHNJ+RBS5EhYUBJBlO7/xcLTmDenvaifZfHEprTp5SnpoSKyawDJUvz1Pt7pFRvQdvvfLSsbrcjq8ato0G1HGdKdFava3UZzFd0NZxKoSe8BeqCtq07kizwIWocDCAJMOJtO7ItRMl2j7IrBGGanbK1OTkVQ8JEPNNGfG4xY61rZrAokTt7pFR75PH5cL8CbWY21CNgXgCZSVexZ3HoYqxkMKs6m0tBW1aOxwU4/tCVKwYQJJp8u1YKe1EieQMmtHTTmSnTDQnTyRPTakPppMmsCjtHpnxPvk87mHBuSgzdwStZkT19khKBW2LZk+UvS715jMW0/tCVKwYQJIt1O5EqckZNKOYRGSnTCQnT22emmgfTCPHvWmltHtkde/B0ShdpX2092P0XYygqjSIqTVTFKu3c9Fa0KY1nzHXvHUich4GkGQ5o3eijC4m0bI+tTl5avPUtPbBdIJcu0dO7D3oVFqLjLRWb+eip6BNJJ9Rad46ETkPA0iynNE7UUYXk2hZn9qcPDV5alqPDZ3O6qKfQmRUkZFS9bbaaUF6muCL5DPmn141KedzEJF9GECS5czYiTKymETP+tI5ealoFLFQ9oemmjy17vMXLOuDKUpkNrkcpxT9OJVZxWBpWqYFpQvXOk6F0Bv5QrGgbSSlfEanzlsnovwYQJLljNiJGrmDYmQxiZ71qfmAVspT03psqDe4y0frbPKR7Cz6sWJGd97nVziWNqPIaCQts6bTBW0/XXQZTp0OGX59aZm3TkT2YwBJttC6E6UUoBlVTKJ1fWo+oJXy1ESPDY0K7vIxOifTyqIfq2Z053x+lcfSZhcZ6Z0WVOrzmrLzbcT0KiKyHgNIsoXWnSgtOyjAl7s/qaS6nSct6xP9gM6XpybSB9Psghun5WSKFphovWaMovZY2uwiI629Gc1mxPQqIrIeA0iylchOlJYdlJG7P6F/VcJXNkn9hBqB9Rn5Aa22D6YVwZ2Vs8nz0VJgYuWMbtnnFziWNrvIyMmzpvVOryIi6zGApIKhJUAbufsTuxhG7KJxRQlDmfEBrdQH04rgTiQn08w8Qy0FJnbvuokeS5tZZOTkWdMi06uIyBkYQJKjxJKpnG1wRAM0K4oShrLjA1pPnz611ORkmp1nqPW9tHvXTfRY2uwiI6tnTYvOe883vYqInIUBJDlCUpKw40yvbCNuj8sFQDxAs2PyidUf0Hr69IlQysk0O89Q63tpVFCvtbG31mNps4qMrJo1beS8dyJyJgaQ5Ag7zvQOGwUYjiUyt+dPqM18XSRAs2PyiVUf0EOJFNxolS8n04o8Qz3vpZ6g3ojG3k7sfWn2rGmRee9EVJgYQJLtYskUjkUGZe87FhnE3IbqzHG2SIBm5+QTsz+gh1JbcGMEuZxMK/IM9byXeoJ6Ixp729n70g5q570TUWHjkFGy3UA8gUgsIXtfJJbAQDz7vnSAphQIVI6bi0DtDfCUBAG44CutRKD2hqKcfJIO7qwec5jOM5S9z8A8w5HvpackKPRe5rpmUtEoYt3dSEWH55Eq5l2m4kLrd7tLUOKvKurgEVA3752ICh93IMl2ZSVeBH1ehGWCyKDPi7IS7ZfpyN2fsVdcgVCffNUyaWNV8ZDRO3n5Cn8Ae3Joi4Gaee9EVPi4A0m283ncmBwMyN43ORjIqsbWIrP7w6MzU9QuvgvBllZ4q2sAtxve6hoEW1pNKR4yaicvXfiTCIUAScoU/vRs2wrgy7xLOWbl0BaD9Lx3Oel570RU+LgDSY5w65U1ACBbhU36mT0H2o7iIT2UCn+S0aitObSFTmneOxEVPgaQ5AgelwvzJ9RibkN1zj6QorS2XikmVs+BtrJ4SA+lwp9YXxjwjnFkBXUhUJr3TkSFjwEkOYrP40a1zg+afK1XRhu750A7lVKDcV9VJXA+NuoqqI2Wb947ERU25kBS0Um3XkkXQKRbr4Q/e9fmlVlL6Zh2ZNVxoYslY+i5EEIsGVN8bLrwR05gxgx4Rhy/j5YKaiIitbgDSUVFsfWKiuCiWNg9B1qrfOMs5WidemL11CAiomLCAJKKilLrlXj0PADnFncYye450KLUjLOUo3XqSaEV/hAROQmPsKmoKLVeKfGXy94XjyfRH/4C8XjSzOVZSumY1mnBUnqcZTiWgIQvx1nuONOb83uUpp6oPc5W05SeiIi+xB1IKiqKrVc8PgBf5v6lUim8t+cUPjnei8HzUQTK/bi6qQY3NU+E2134f18VyjGtyDjLodRMPWERBxGR8RhAUtERab3y3p5TOPrBZ5nbg+ejmduzWiZZs2ATFcoxrZpxlnLV+Zx6QkRkDwaQVHTUtl6Jx5P45Lj88ejp4724cXYjSiyeK20Wp/dn1DrOMj31ZGgOZBqnnhARmafwz+iIclBqvXJhMIbB8/KtbAYHorgwOHoqttWIxpPoDl9A1IQ8UT3jLO+4pg3fbpiF6tJKuOBCdWklvt0wi1NPiIhMxB1IGrUuD/gQKPfLBpGBMj8uD3D3CgCSqRRe23MSR473oO98FFXlfsxoqsUPmq+Bx8A8Ua3jLDn1hIjIegwgadQqKfHg6qaaYTmQaVc11RTN8bVer+05iV0ffJq5HTofzdz+YUuTYc+jd5wlp54QEVmHR9g0qt3UPBFTrx+HsnI/XC6grNyPqdePw03NE+1emiNE40kcOd4je9+R472mHWdXl/p0z0I3QioaRay7u+im9hAR6cUdSBrV3G43ZrVMwo2zG3FhMIbLAz7uPA7RPxhFX4480fDARfQPRlFXebnFqzKflEyie+urGDzyDyT6+uCtqkJgxnWoXXwXXB5eH0RE9v+JT+QAJSUeVFRexuBxhIqAH1Xl8m1/KstKURHQ3hLIyc3bP/nv/0Fk185LU3wkCYlQCJFdO9GzbavdSyMicgTuQBJRTv4SD2Y01Q7LgUyb0VQDv4aA2+nN21PRKPoOZzeiBy41ZK+5/U5H9tIkIrISA0giyusHzdcAuJTzGB64iMqyUsxoqsl8XZTTm7cn+vsR7ZHvD5oI9yHR3+/onppERFZgAElEeXncbvywpQmLZk9E/2AUFQG/pp1HoDCat3srKuCvrUG0O7t4yFtZBW+F/Kx1IqLRxP7zIiIqCP4SD+oqL9ccPAKF0bzd7fej6oYbZO8LzJjB42siInAHkogsVCjN26/+8T344mIMg0eOIBHug7eyCoEZM1C7+C5Lnj+WTGnqhUlEZBUGkERkmUJp3u7yeFB3192ouf1OJPr74a2osGTnMSlJ2HGmV3Yaj8flMv35iYjUYgBJRJZKN2k/fbwXgwNRBMr8uOo/VdjApeblenMtjeL2+y0tmNlxphfvdUcyt8OxROb2/Am1lq2DiEgJA0gislSu5u3JVAr/u+u46TO3nSqWTOFYZFD2vmORQcxtqOZxNhE5BgNIIrJFunl7mlUzt51qIJ5AJJaQvS8SS2AgnkC1xxk5okRE/HOWiGxnx8xtpykr8SLok/+bPujzoqyEf+8TkXMwgCQi26mZuV3sfB43JgcDsvdNDgZ4fE1EjsI/aYnIdumZ2yGZIFLvzO1CcuuVNQAgW4VNROQkDCCJilQqGrW0BY0eZszcLkQelwvzJ9RibkM1+0ASkaMxgCQqMlIyiZ5tWzF45B9I9PXBW1WFwIzrULv4Lrg8zg3EjJ65Xch8HjcLZojI0RhAEhWZnm1bEdm1M3M7EQplbtfddbddy1Jk5MxtIiIyF89GiIpIKhrF4JF/yN43eOQIUlHnF6MYMXObiIjMpSuA3LFjB9ra2vDVr34VR48eHXbfxo0b0drainnz5uHAgQO6FklE6iT6+5Ho65O/L9yHRH+/xSsiIqJipCuAbGpqwvr16zFz5sxhXz958iTa29vR3t6OTZs24emnn0YyWfx93Ijs5q2ogLeqSv6+yip4KyosXhERERUjXQHkxIkT0djYmPX13bt3o62tDT6fD+PHj8eECRPQ0dGh56mISAW334/AjOtk7wvMmOH4amwiIioMphTRdHV1Yfr06Znb9fX16OrqUvy+ysrL4fVqy3uqrS3T9H3Fjq9LtmJ/TWoeuh+flPrQd/j/EO3thb+mBlU3zMTVP74nZxV2sb8mWvA1ycbXJBtfk2x8TbIV42uiGEAuXboUvb29WV9fsWIFWlpaDF1MOHxB0/fV1pahp2fA0LUUA74u2UbLa1J222KMuXXhsD6QvX3yv1+j5TURwdckG1+TbHxNsvE1yVbIr0m+wFcxgNy8ebPwE9bX1+PcuXOZ211dXaivrxf+d4hIO7ffD19dnd3LICKiImRKG5/m5ma0t7cjFouhs7MTp0+fxrRp08x4KiIiIiKymK4cyJ07d+KZZ55BX18ffvrTn2Ly5Ml4+eWXMWnSJNx666347ne/C4/Hg1//+tfwOHgCBhERERGppyuAbG1tRWtrq+x9y5Ytw7Jly/T880RERETkQJxEQ0RERERCGEASERERkRAGkEREREQkhAEkEREREQlhAElEREREQhhAEhEREZEQBpBEREREJIQBJBEREREJYQBJREREREIYQBIRERGREAaQRERERCSEASQRERERCWEASURERERCGEASERERkRAGkEREREQkhAEkEREREQlhAElEREREQhhAEhEREZEQBpBEREREJIQBJBEREREJYQBJREREREIYQBIRERGREJckSZLdiyAiIiKiwsEdSCIiIiISwgCSiIiIiIQwgCQiIiIiIQwgiYiIiEgIA0giIiIiEsIAkoiIiIiEeO1egFo7duzAH/7wB5w6dQrbtm3D1KlTM/dt3LgRr7/+OtxuN5588kl885vfzPr+zs5OrFq1CpFIBFOmTMG6devg8/ms/BFMtWLFCnzyyScAgIGBAZSVleHPf/5z1uOam5sxZswYuN1ueDwevPnmm1Yv1VLr16/Hn/70J1RVVQEAVq1ahdmzZ2c9bv/+/VizZg1SqRQWL16MBx54wOqlWub555/HX//6V5SUlODKK6/E2rVrUV5envW40XCtKL3vsVgMjz76KD7++GMEg0G88MILaGhosGm15jt79iweffRRhEIhuFwufP/738c999wz7DF///vf8dBDD2Veh9bWVvzsZz+zY7mWUfpdkCQJa9aswb59+1BaWornnnsOU6ZMsWm15vvXv/6FlStXZm53dnZi+fLlWLp0aeZro+E6efzxx7F3715UV1dj+/btAIBIJIKVK1fis88+w7hx4/Diiy+ioqIi63vfeustbNiwAQCwbNky3H777Zau3RBSgTh58qR06tQp6Uc/+pHU0dGR+fqJEyekBQsWSNFoVDpz5ow0Z84cKZFIZH3/8uXLpe3bt0uSJElPPfWU9Oqrr1q2dqutXbtWWr9+vex9t9xyixQKhSxekX1+//vfS5s2bcr7mEQiIc2ZM0c6c+aMFI1GpQULFkgnTpywaIXWO3DggBSPxyVJkqR169ZJ69atk31csV8rat73V155RXrqqackSZKk7du3S7/4xS/sWKplurq6pI8++kiSJEkaGBiQ5s6dm/WaHDp0SHrggQfsWJ5tlH4X9u7dK913331SKpWSjhw5It15550Wrs5eiURCuummm6RPP/102NdHw3Vy+PBh6aOPPpLa2toyX3v++eeljRs3SpIkSRs3bpT9/2s4HJaam5ulcDgsRSIRqbm5WYpEIpat2ygFc4Q9ceJENDY2Zn199+7daGtrg8/nw/jx4zFhwgR0dHQMe4wkSTh06BDmzZsHALj99tuxe/duS9ZtNUmSsGPHDsyfP9/upRSMjo4OTJgwAePHj4fP50NbW1vRXh8AMGvWLHi9lw4frr32Wpw7d87mFdlDzfu+Z8+ezM7AvHnz8P7770Mq4tkLdXV1mZ2zQCCAxsZGdHV12bwq59u9ezduu+02uFwuXHvttTh//jy6u7vtXpYl3n//fYwfPx7jxo2zeymWmzlzZtbuYvpaAIDbbrsNu3btyvq+gwcP4uabb0YwGERFRQVuvvlmHDhwwJI1G6lgAshcurq6MHbs2Mzt+vr6rP/hhcNhlJeXZz40x44dW7T/U/zggw9QXV2Nq666Kudj7rvvPtxxxx147bXXrFuYjV599VUsWLAAjz/+OPr7+7PuV3MNFas33ngD3/rWt3LeX8zXipr3vaurC1dccQUAwOv1oqysDOFw2NJ12uXTTz/FsWPHMH369Kz7PvzwQyxcuBA/+clPcOLECRtWZ718vwsjr6Vi/owZqb29PeeGxWi8TkKhEOrq6gAAtbW1CIVCWY8pls8cR+VALl26FL29vVlfX7FiBVpaWmxYkbOoeX22b9+ed/dxy5YtqK+vRygUwr333ovGxkbMnDnTtDVbId/rsmTJEjz00ENwuVx46aWX8Nxzz2Ht2rU2rNJaaq6VDRs2wOPxYOHChbL/RjFeK6TO559/juXLl+OJJ55AIBAYdt+UKVOwZ88ejBkzBvv27cPDDz+Md99916aVWoO/C/JisRj27NmDX/7yl1n3jcbrZCSXywWXy2X3MkzjqABy8+bNwt9TX18/7Aiuq6sL9fX1wx5TWVmJ8+fPI5FIwOv14ty5c1mPKQRKr08ikcDOnTvzFjukf+7q6mq0traio6Oj4P9HqPa6Wbx4MR588MGsr6u5hgqN0mvy5ptvYu/evdi8eXPO/8EV47UylJr3vb6+HmfPnsXYsWORSCQwMDCAyspKq5dqqXg8juXLl2PBggWYO3du1v1DA8rZs2fj6aefRl9fX6ZQrRgp/S6MvJYK9TNG1P79+zFlyhTU1NRk3TcarxPg0jXS3d2Nuro6dHd3y/689fX1OHz4cOZ2V1cXbrjhBiuXaYiCP8Jubm5Ge3s7YrEYOjs7cfr0aUybNm3YY1wuF2688Ua88847AC5VPzU3N9uxXFO99957aGxsHLY1PtSFCxcwODiY+e+//e1vmDRpkpVLtNzQPKRdu3bJ/rxTp07F6dOn0dnZiVgshvb29qK8PtL279+PTZs2YcOGDbjssstkHzMarhU173tzczPeeustAMA777yDr3/960W9oyBJEn71q1+hsbER9957r+xjenp6MnmgHR0dSKVSRR1Uq/ldaG5uxttvvw1JkvDhhx+irKwsc4xZzNrb29HW1iZ732i7TtLS1wIAvP3225gzZ07WY2bNmoWDBw+iv78f/f39OHjwIGbNmmX1UnVzSQWSEb5z504888wz6OvrQ3l5OSZPnoyXX34ZwKWjuDfeeAMejwdPPPFEpk3L/fffj9/85jeor69HZ2cnVq5cif7+fkyePBm//e1vi6qNDwA89thjmD59OpYsWZL5WldXF5588kn88Y9/RGdnJx5++GEAQDKZxPz587Fs2TK7lmuJRx55BP/85z8BAOPGjcPq1atRV1c37HUBgH379uHZZ59FMpnEokWLivp1aW1tRSwWQzAYBABMnz4dq1evHpXXitz7/tJLL+FrX/sa5syZg2g0ikceeQTHjh1DRUUFXnjhBYwfP97uZZvmgw8+wN13342mpia43Zf2F1atWoV///vfAIAlS5bglVdewZYtW+DxeFBaWorHHnsM1113nZ3LNlWu34UtW7YAuPSaSJKE1atX48CBA7jsssvw7LPPDms1V4wuXLiAW265Bbt27UJZWRkADHtNRsN1smrVKhw+fBjhcBjV1dX4+c9/jpaWFqxYsQJnz57FV77yFbz44osIBoM4evQotm7dijVr1gAAXn/9dWzcuBEA8OCDD2LRokV2/iiaFEwASURERETOUPBH2ERERERkLQaQRERERCSEASQRERERCWEASURERERCGEASERERkRAGkEREREQkhAEkEREREQlhAElEREREQv4f0DLkl6GdPOMAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7fc2d1b932b0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "ax_min = np.min(logits_test,0)\n",
    "ax_max = np.max(logits_test,0)\n",
    "ax_dist_sq = np.sum((ax_max-ax_min)**2)\n",
    "plt.figure(figsize=(11,11))\n",
    "ax = plt.subplot(111)\n",
    "shown_images = np.array([[1., 1.]])\n",
    "colors = sns.color_palette(n_colors=len(dataset.target_names))\n",
    "for i in range(manifold_emotions.shape[0]):\n",
    "    dist = np.sum((manifold_emotions[i] - shown_images)**2, 1)\n",
    "    if np.min(dist) < 3e-4*ax_dist_sq:\n",
    "        continue\n",
    "    shown_images = np.r_[shown_images, [manifold_emotions[i]]]\n",
    "    plt.scatter(manifold_emotions[i,0],manifold_emotions[i,1],c=colors[Y[i]])\n",
    "plt.legend(dataset.target_names)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
